2022/01/21

2022-01-21 00:00:28 +0100 <EvanR> how the heck did your first x gain more polymorphism after be explicitly less polymorphic
2022-01-21 00:00:53 +0100 <int-e> Which makes the let (a, b) = x in (a, b) case a bit surprising because it doesn't *look* like it duplicates a computation.
2022-01-21 00:01:10 +0100 <monochrom> Well, if the user supplies a type sig, the compiler is obliged to not generalize that behind your back.
2022-01-21 00:01:13 +0100 <int-e> But in fact it does!
2022-01-21 00:01:31 +0100 <int-e> (Though ghc will be smart about it if it knows that the type is the same)
2022-01-21 00:01:39 +0100 <monochrom> But if you define "x = (0,1)" without type sig and without MMR, you do get x :: (Num a, Num b) => (a, b).
2022-01-21 00:02:17 +0100alphabeta(~kilolympu@31.205.200.235)
2022-01-21 00:02:25 +0100kilolympus(~kilolympu@31.205.200.235) (Ping timeout: 256 seconds)
2022-01-21 00:06:10 +0100jiribenes_(~jiribenes@rosa.jiribenes.com)
2022-01-21 00:06:39 +0100 <EvanR> :t let x :: Num a => (a,a); x = (0,1); y = (fst x, snd x) in y
2022-01-21 00:06:40 +0100 <lambdabot> (Num a, Num b) => (a, b)
2022-01-21 00:06:47 +0100eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2022-01-21 00:06:58 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-21 00:07:49 +0100liskin(~liskin@xmonad/liskin) (Ping timeout: 240 seconds)
2022-01-21 00:07:49 +0100jiribenes(~jiribenes@rosa.jiribenes.com) (Ping timeout: 240 seconds)
2022-01-21 00:08:08 +0100 <monochrom> WWWHHHHYYYY... :)
2022-01-21 00:08:08 +0100liskin(~liskin@xmonad/liskin)
2022-01-21 00:08:30 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Remote host closed the connection)
2022-01-21 00:08:33 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net)
2022-01-21 00:08:43 +0100 <EvanR> is it really possible for a /= b here... but the explicit sig...
2022-01-21 00:08:57 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881)
2022-01-21 00:09:02 +0100 <monochrom> The explicit sig is explicitly polymorphic.
2022-01-21 00:09:18 +0100 <EvanR> (a,a) but you can pick two different a? xD
2022-01-21 00:09:27 +0100 <EvanR> I would fail algebra
2022-01-21 00:09:30 +0100 <monochrom> fst x gets one "a", snd x gets a different "a".
2022-01-21 00:09:47 +0100 <int-e> > let x = 0 in (x, x) -- EvanR: YES!
2022-01-21 00:09:48 +0100 <EvanR> oh, it's two different x
2022-01-21 00:09:48 +0100 <lambdabot> (0,0)
2022-01-21 00:09:54 +0100 <int-e> :t let x = 0 in (x, x)
2022-01-21 00:09:55 +0100 <lambdabot> (Num a, Num b) => (a, b)
2022-01-21 00:09:55 +0100 <monochrom> OK, here is an elementary example:
2022-01-21 00:10:08 +0100 <int-e> (oops, > and :t are not the same)
2022-01-21 00:10:12 +0100 <monochrom> let f = \x->x in (f True, f 4)
2022-01-21 00:10:13 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2022-01-21 00:10:22 +0100 <ski> spelling out the `forall's might make it clearer, i guess
2022-01-21 00:10:44 +0100 <monochrom> Now no one complained that f has two types, did you?
2022-01-21 00:11:16 +0100 <EvanR> f has two types, and before x had two types, both uniform (a,a), (b,b)
2022-01-21 00:11:20 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Remote host closed the connection)
2022-01-21 00:11:21 +0100 <monochrom> So why suddenly complain about x having two types.
2022-01-21 00:11:23 +0100 <EvanR> tricky tricky
2022-01-21 00:11:24 +0100 <int-e> monochrom: I didn't complain when we had the monomorphism restriction either.
2022-01-21 00:11:33 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881)
2022-01-21 00:11:47 +0100 <int-e> both ways make some amount of sense and have their own nasty surprises
2022-01-21 00:12:06 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 00:12:13 +0100 <int-e> EvanR: oh sorry btw for using x instead of a ;-)
2022-01-21 00:16:46 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 00:19:25 +0100chomwitt(~chomwitt@athedsl-15695.home.otenet.gr) (Ping timeout: 256 seconds)
2022-01-21 00:19:51 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2022-01-21 00:20:45 +0100 <zzz> excellent
2022-01-21 00:25:50 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 256 seconds)
2022-01-21 00:25:53 +0100notzmv(~zmv@user/notzmv)
2022-01-21 00:31:39 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 00:33:30 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2022-01-21 00:36:48 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao) (Ping timeout: 276 seconds)
2022-01-21 00:37:49 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao)
2022-01-21 00:38:52 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2022-01-21 00:39:11 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-21 00:40:48 +0100Guest24(~Guest24@144-124-136-14.pip.aber.ac.uk)
2022-01-21 00:42:15 +0100 <Guest24> hi could you help me with this please I keep getting an indentation error
2022-01-21 00:42:16 +0100 <Guest24> https://paste.tomsmeding.com/MU3TLGUF
2022-01-21 00:42:39 +0100hyiltiz(~quassel@31.220.5.250) (Ping timeout: 256 seconds)
2022-01-21 00:43:51 +0100 <monochrom> Delete "let "
2022-01-21 00:44:10 +0100 <zzz> that let doesn't belong there
2022-01-21 00:44:18 +0100hyiltiz(~quassel@31.220.5.250)
2022-01-21 00:44:19 +0100 <monochrom> The type "[numbers] -> result" reflects very wrong concept.
2022-01-21 00:45:59 +0100 <Guest24> so should i change the result to int
2022-01-21 00:46:25 +0100 <Axman6> probably the easiest thing would be to change the type to negsum :: [Int] -> Int
2022-01-21 00:47:08 +0100 <Guest24> https://paste.tomsmeding.com/9gTFmffy
2022-01-21 00:47:16 +0100 <Axman6> it's very important to undertstand what that's saying, that nugsum is a function (->) that takes a list of Ints as its input and returns an Int as its output
2022-01-21 00:47:28 +0100 <Axman6> no, int is not Int
2022-01-21 00:48:08 +0100 <Axman6> int ius a type variable, that's the same as writing negsum :: [a] -> a, it's saying that the type contained in the list could be literally anything
2022-01-21 00:48:11 +0100simpleauthority(~simpleaut@user/simpleauthority) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-21 00:48:31 +0100 <monochrom> Are you supposed to do addition? Where do you use the + operator?
2022-01-21 00:48:31 +0100 <Axman6> Int is a concrete type for (smallish) integers
2022-01-21 00:48:36 +0100 <geekosaur> also, what causes you to redundantly say `== True`?
2022-01-21 00:48:44 +0100 <Guest24> thank you
2022-01-21 00:49:07 +0100 <Axman6> > (False == True, True == True)
2022-01-21 00:49:09 +0100 <lambdabot> (False,True)
2022-01-21 00:49:20 +0100 <Axman6> @check \x -> (x == True) == x
2022-01-21 00:49:21 +0100 <lambdabot> +++ OK, passed 100 tests.
2022-01-21 00:49:35 +0100 <Guest24> well i want my function to check if the value I took from the array is less than 0 (so negative) and then return the sum of those numbers
2022-01-21 00:49:58 +0100simpleauthority(~simpleaut@user/simpleauthority)
2022-01-21 00:49:59 +0100 <monochrom> People coming from javascript probably think of "foo", "foo == True", "foo === True", "foo ==== True" as all different things.
2022-01-21 00:50:04 +0100 <Axman6> better to call it a list, an array is something different
2022-01-21 00:50:11 +0100 <jackdk> geekosaur: the two causes I usually see: previous experience in a dynamic language where such an expression doubles as a type-check, or not yet realising that `== True` never adds additional information
2022-01-21 00:50:18 +0100 <jackdk> monochrom: are we up to four equals now?
2022-01-21 00:50:43 +0100 <Axman6> equalAF(a,b) = a ================ b
2022-01-21 00:50:44 +0100 <jackdk> (both are fine, that how learning works)
2022-01-21 00:50:55 +0100 <monochrom> And people coming from python think of "array", "list", "hash table", "dictionary", "set" as all the same thing.
2022-01-21 00:50:57 +0100 <hpc> this is why i always write "foo = True"
2022-01-21 00:51:00 +0100 <hpc> it's the only way to be sure
2022-01-21 00:51:09 +0100 <monochrom> The two anti-intellectual extremes of programming languages.
2022-01-21 00:51:16 +0100 <Guest24> im sorry im really confused now
2022-01-21 00:51:28 +0100 <Axman6> what are you confused about?
2022-01-21 00:51:31 +0100 <monochrom> OK I'm joking about ====, but don't be surprised if you see it happen in the future!
2022-01-21 00:52:32 +0100 <Axman6> (====) :: SuperEq a => a -> a -> Bool -- ^ Checks that y and y are the same, they were defined in exactly the same place in the code, in the same program, in the same git commit
2022-01-21 00:52:41 +0100 <ephemient> @check True ==> True
2022-01-21 00:52:42 +0100 <lambdabot> +++ OK, passed 100 tests.
2022-01-21 00:52:52 +0100 <Guest24> im essentially supposed to change filter(\x -> (x<0) == True) numbers into a function
2022-01-21 00:53:06 +0100 <hpc> why are you doing "== True" though
2022-01-21 00:53:09 +0100 <hpc> why not just (x < 0)
2022-01-21 00:53:24 +0100 <Guest24> idk it didn't work when it just did that
2022-01-21 00:53:32 +0100 <monochrom> At this rate I wonder if "foo == True" comes straight from the teacher.
2022-01-21 00:53:42 +0100 <hpc> i think you changed more things than just adding "== True" between tests
2022-01-21 00:53:56 +0100 <Guest24> i guess that's true
2022-01-21 00:54:01 +0100 <monochrom> Like, today is basically "==True" having a field day.
2022-01-21 00:54:27 +0100 <Axman6> Guest24: there are other problems with your code, we're going through them one at a time, focusing on the most helpful first. telling us "it didn't work" doesn't give us any information to help you, what is "it"? what error did you get?
2022-01-21 00:54:57 +0100 <monochrom> Although, I still recommend against picking on it. There are many more pressing concerns.
2022-01-21 00:55:18 +0100johnjaye(~pi@173.209.65.233) (Ping timeout: 256 seconds)
2022-01-21 00:55:37 +0100 <hpc> monochrom: the elephant in the room casts a long shadow
2022-01-21 00:55:38 +0100 <monochrom> An algorithm for summing that uses : instead of + for example.
2022-01-21 00:55:48 +0100 <Guest24> with the code i currently have posted there is this error
2022-01-21 00:55:55 +0100 <Guest24>  * Couldn't match expected type `[int]' with actual type `int'
2022-01-21 00:55:55 +0100 <Guest24>       `int' is a rigid type variable bound by
2022-01-21 00:55:56 +0100 <Guest24>         the type signature for:
2022-01-21 00:55:56 +0100 <Guest24>           negsum :: forall int. [int] -> int
2022-01-21 00:55:57 +0100 <Guest24>         at question2.hs:4:1-22
2022-01-21 00:55:57 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 240 seconds)
2022-01-21 00:55:57 +0100 <Guest24>     * In the second argument of `(:)', namely `negsum xs'
2022-01-21 00:55:58 +0100 <Guest24>       In the expression: x : negsum xs
2022-01-21 00:55:58 +0100 <Guest24>       In the expression:
2022-01-21 00:55:59 +0100 <Guest24>         if (x < 0) == True then x : negsum xs else negsum xs
2022-01-21 00:55:59 +0100 <Guest24>     * Relevant bindings include
2022-01-21 00:56:00 +0100 <Guest24>         xs :: [int] (bound at question2.hs:6:11)
2022-01-21 00:56:00 +0100 <Guest24>         x :: int (bound at question2.hs:6:9)
2022-01-21 00:56:00 +0100 <Axman6> use the pastye wensite!
2022-01-21 00:56:01 +0100 <Guest24>         negsum :: [int] -> int (bound at question2.hs:5:1)
2022-01-21 00:56:01 +0100 <Guest24>   |
2022-01-21 00:56:02 +0100 <Guest24> 8 | then x:negsum xs
2022-01-21 00:56:02 +0100 <Guest24>   | ^^^^^^^^^
2022-01-21 00:56:03 +0100 <Axman6> website*
2022-01-21 00:56:15 +0100 <monochrom> It is not a long shadow unless it's "((foo == True) == True) == (True == True)" haha
2022-01-21 00:56:26 +0100 <geekosaur> you can include error messages in your paste
2022-01-21 00:56:33 +0100 <Guest24> https://paste.tomsmeding.com/WGy62gW1
2022-01-21 00:56:33 +0100 <Axman6> you can post code and the error you got with it at the saem time, please do that and don't paste multiple lines in here
2022-01-21 00:56:46 +0100 <Guest24> sorry i didn't know :(
2022-01-21 00:56:51 +0100 <geekosaur> looks to me like you are still not recognizing that `int` is not the same as `Int`
2022-01-21 00:56:57 +0100 <geekosaur> Haskell is case sensitive
2022-01-21 00:57:14 +0100 <monochrom> You are still not taking Axman6's advice that int is not Int. You want Int.
2022-01-21 00:57:21 +0100johnjaye(~pi@173.209.65.233)
2022-01-21 00:57:59 +0100 <monochrom> See this is what happens when everyone discusses ==True.
2022-01-21 00:57:59 +0100 <Guest24> https://paste.tomsmeding.com/HKo31Fqa
2022-01-21 00:58:10 +0100 <Axman6> > "int" == "Int"
2022-01-21 00:58:11 +0100 <lambdabot> False
2022-01-21 00:58:25 +0100 <jackdk> you are writing lowercase `i` where a capital `I` is required
2022-01-21 00:58:48 +0100 <Guest24> https://paste.tomsmeding.com/V3pzH0y2
2022-01-21 00:58:53 +0100 <geekosaur> the first oart of the past eshows it changed, the error does not
2022-01-21 00:59:05 +0100 <jackdk> ah right sorry
2022-01-21 00:59:15 +0100 <Axman6> geekosaur: that error doesn't match the code you pasted
2022-01-21 00:59:22 +0100 <Axman6> uh, Guest24*
2022-01-21 00:59:30 +0100glassy(~glassy@user/glassy)
2022-01-21 00:59:30 +0100 <Axman6> ok, better
2022-01-21 00:59:34 +0100 <Guest24> its the erro i got tho
2022-01-21 00:59:35 +0100 <Axman6> (sorry, a bit behind)
2022-01-21 00:59:42 +0100 <Guest24> ok sorry
2022-01-21 00:59:45 +0100 <Axman6> ok, do you know what : does?
2022-01-21 00:59:52 +0100 <glassy> hi, is it possible to overload the 'if then else' syntax with TemplateHaskell?
2022-01-21 01:00:24 +0100 <glassy> I would like it to be more flexible so I can use monadic if
2022-01-21 01:00:24 +0100 <hpc> glassy: you want RebindableSyntax
2022-01-21 01:00:38 +0100 <hpc> https://downloads.haskell.org/~ghc/7.0.2/docs/html/users_guide/syntax-extns.html#rebindable-syntax
2022-01-21 01:00:58 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 01:02:22 +0100 <Axman6> Guest24: do you know what : does?
2022-01-21 01:02:36 +0100 <glassy> if you use RebindableSyntax, does using import Prelude bring it back to normal?
2022-01-21 01:02:44 +0100 <glassy> just changing ifThenElse is the only thing I wish to change
2022-01-21 01:02:58 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 01:03:09 +0100 <Guest24> it's the cons operation?
2022-01-21 01:03:27 +0100 <hpc> glassy: yeah
2022-01-21 01:03:39 +0100 <hpc> import Prelude hiding (ifThenElse)
2022-01-21 01:04:36 +0100 <ephemient> there is no ifThenElse in Prelude
2022-01-21 01:05:08 +0100 <monochrom> But it becomes a thing under RebindableSyntax; see the doc there.
2022-01-21 01:05:17 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 240 seconds)
2022-01-21 01:05:29 +0100 <monochrom> (I was thinking that too. So I clicked the link. Best decision ever.)
2022-01-21 01:05:57 +0100 <Axman6> Guest24: it is, which means that when you write x:negsum xs you must be returning a list, right?
2022-01-21 01:06:13 +0100 <Axman6> :t (:)
2022-01-21 01:06:14 +0100 <lambdabot> a -> [a] -> [a]
2022-01-21 01:06:15 +0100 <Guest24> yh that's true
2022-01-21 01:06:34 +0100 <Axman6> based on the name of your function, I assume you actually want to add things, right?
2022-01-21 01:07:09 +0100 <Axman6> you know that x is an Int, andf you know that, because of the type of negsum, that negsum applied to xs will also return an Int, right?
2022-01-21 01:07:29 +0100 <Guest24> i want write a recursive function that will take each value from the list and test it under the condition. if the condition is satisfied it will add that value to the running sum of the negative numbers in the list
2022-01-21 01:08:00 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Ping timeout: 276 seconds)
2022-01-21 01:08:04 +0100 <Guest24> im sorry i come from imperative programming so this is very hard for me to grasp
2022-01-21 01:08:26 +0100 <glassy> i'm a bit confused how I would use it though. ifThenElse :: (ToBool p, Monad m) => m p -> m a -> m a -> m a. ifThenElse :: ToBool p => p -> a -> a -> a
2022-01-21 01:08:30 +0100 <glassy> i would like both signatures to work
2022-01-21 01:08:35 +0100 <glassy> but they seem incompatible
2022-01-21 01:08:46 +0100 <EvanR> Guest24, fun fact you can translate any imperative algorithm to functional using One Weird Trick
2022-01-21 01:09:09 +0100 <Guest24> please tell me the trick
2022-01-21 01:09:29 +0100 <EvanR> well I dunno about one weird trick, but it's pretty formulaic and may help you transition
2022-01-21 01:09:33 +0100max22-(~maxime@2a01cb08833598008b56a1095c0012ed.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2022-01-21 01:09:34 +0100 <Axman6> I think it's best to just make the one character change to this function to make it work first EvanR
2022-01-21 01:09:45 +0100 <EvanR> yeah do that instead
2022-01-21 01:10:06 +0100 <Axman6> Guest24: you're supposed to be returning an Int, but instead you're returning a list of Ints, right? can you see that?
2022-01-21 01:10:17 +0100 <Guest24> yes i can
2022-01-21 01:10:38 +0100 <Axman6> but you're trying to add together all the negative values, and you haven't use + anywhere
2022-01-21 01:10:40 +0100 <glassy> can I replace ifThenElse with a typeclass instance instead of an actual function?
2022-01-21 01:10:51 +0100 <ephemient> {-# LANGUAGE RebindableSyntax #-} import Prelude; main = if True then print 1 else print 0 -- error: Not in scope: `ifThenElse'
2022-01-21 01:11:34 +0100 <Guest24> so i think that what i want to do is in the then part of the if statement is add the x value to something and the call the function again with the tail of the list as the parameter
2022-01-21 01:11:48 +0100 <ephemient> hiding (ifThenElse) doesn't change that
2022-01-21 01:11:52 +0100 <Axman6> you're thinking imperatively
2022-01-21 01:11:56 +0100 <hpc> glassy: i think as long as it can be called as "if _ then _ else _" you're good to go
2022-01-21 01:11:56 +0100 <Guest24> :((
2022-01-21 01:12:01 +0100 <Axman6> you can just add things together
2022-01-21 01:12:09 +0100 <hpc> so yeah
2022-01-21 01:12:10 +0100 <Axman6> x is an Int, negsum xs is an Int
2022-01-21 01:12:32 +0100 <Axman6> (+) takes two Ints and adds them
2022-01-21 01:13:00 +0100 <Guest24> what would i add the x value to
2022-01-21 01:13:05 +0100 <EvanR> when you evaluate 2 + 2, you get 4. You don't update something holding a number
2022-01-21 01:13:17 +0100 <EvanR> that's how haskell works
2022-01-21 01:13:18 +0100 <Guest24> can i use the built-in function filter
2022-01-21 01:13:23 +0100 <glassy> thanks hpc, I will give it a shot. it feels very hacky haha :), hopefully little type level magic needed
2022-01-21 01:13:27 +0100 <Guest24> or foldl
2022-01-21 01:13:27 +0100 <Axman6> > let f y = y^2 in 7 + f 14
2022-01-21 01:13:28 +0100 <lambdabot> 203
2022-01-21 01:13:42 +0100 <Axman6> Guest24: you literally only have to change one character to make your code work
2022-01-21 01:13:49 +0100 <hpc> glassy: yeah, the whole extension feels hacky to me
2022-01-21 01:14:01 +0100 <geekosaur> so is pretty much all of RebindableSyntax tbh
2022-01-21 01:14:01 +0100 <glassy> it seems like the kitchensink for overloaded stuff
2022-01-21 01:14:02 +0100 <Axman6> you're returning a list when you're supposed to be adding
2022-01-21 01:14:06 +0100 <hpc> i think if i wanted that kind of syntactic flexibility i would use lisp
2022-01-21 01:14:37 +0100 <glassy> never used lisp
2022-01-21 01:14:43 +0100 <glassy> it looks like too many brackets
2022-01-21 01:14:47 +0100 <glassy> like python
2022-01-21 01:14:59 +0100 <hpc> it is - i had one college course that used common lisp and my laptop's 9 key broke
2022-01-21 01:15:08 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 256 seconds)
2022-01-21 01:15:11 +0100 <glassy> that is really funny
2022-01-21 01:15:44 +0100 <ephemient> just switch to AZERTY keyboard layout, as long as your 5 key still works :p
2022-01-21 01:15:44 +0100 <Axman6> glassy: I'll say it again: x is an Int, negsum, when given a list of Ints returns an Int, so negsum xs is also an Int. (+) takes two Ints and returns an Int. you need an Int
2022-01-21 01:15:56 +0100 <Guest24> https://paste.tomsmeding.com/n9v0edHS
2022-01-21 01:16:25 +0100 <Axman6> Guest24: add numbers :: [Int] above numbers = ...
2022-01-21 01:16:27 +0100 <ephemient> well now you're hitting type defaulting and monomorphism
2022-01-21 01:16:40 +0100 <Guest24> guys i think i did it
2022-01-21 01:16:48 +0100 <ephemient> if you wrote negsum numbers inside the .hs file it would be deduced correctly
2022-01-21 01:16:49 +0100 <geekosaur> mm, but shouldn't that in a module infer it as :: [Int]?
2022-01-21 01:16:54 +0100 <Axman6> you didn;t tell the compiler what type numbers was, so it defaulted to [Integer]
2022-01-21 01:17:11 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net) (Quit: This computer has gone to sleep)
2022-01-21 01:17:13 +0100 <Axman6> and Int and Integer are different types
2022-01-21 01:17:15 +0100 <glassy> Guest24 why not get rid of the positive numbers then sum all of that?
2022-01-21 01:17:17 +0100 <Guest24> https://paste.tomsmeding.com/ljoGkaCW
2022-01-21 01:17:22 +0100 <johnjaye> i'm surprised you can even hit the 9 key on a laptop
2022-01-21 01:17:22 +0100 <johnjaye> let alone any thing like ' or pagedown
2022-01-21 01:17:22 +0100 <johnjaye> this one i have now is an old hp and the arrow keys are super slim and tiny so you can barely use them
2022-01-21 01:17:35 +0100 <Axman6> > (3^253 :: Integer, 3^253 :: Int)
2022-01-21 01:17:37 +0100 <lambdabot> (514846119915350862092369580702449270793403151142700511080017868259392861591...
2022-01-21 01:17:48 +0100 <hpc> johnjaye: this was a while ago
2022-01-21 01:17:55 +0100 <hpc> i had an elegant laptop from a more civilized age
2022-01-21 01:18:09 +0100 <Axman6> glassy: we're covering the basics first
2022-01-21 01:18:25 +0100 <johnjaye> i kinda want to bring my laptop inside but if i disconnect the power it will die in like 5 minutes (bad battery)
2022-01-21 01:18:28 +0100 <glassy> ahh i see, good luck guys :)
2022-01-21 01:18:38 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2022-01-21 01:18:46 +0100Guest96(~Guest96@144-124-99-115.pip.aber.ac.uk)
2022-01-21 01:18:54 +0100 <Axman6> gotta crawl before you can walk, and walk before you can run
2022-01-21 01:20:49 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 01:21:32 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Remote host closed the connection)
2022-01-21 01:21:42 +0100simpleauthority(~simpleaut@user/simpleauthority) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-21 01:21:57 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881)
2022-01-21 01:22:44 +0100 <zzz> FOLLOW UP this is where it gets me:
2022-01-21 01:22:45 +0100 <zzz> w :: (Int,Float)
2022-01-21 01:22:45 +0100 <zzz> w = (fst x, snd x) -- this is ok
2022-01-21 01:22:45 +0100 <zzz> h :: (Int,Float)
2022-01-21 01:22:45 +0100 <zzz> h = let k = x in (fst k, snd k) -- this is DMRed
2022-01-21 01:23:28 +0100 <zzz> reminder that x is:
2022-01-21 01:23:29 +0100 <zzz> x :: Num a => (a,a)
2022-01-21 01:23:29 +0100 <zzz> x = (0,1)
2022-01-21 01:23:51 +0100simpleauthority(~simpleaut@user/simpleauthority)
2022-01-21 01:24:01 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2022-01-21 01:24:33 +0100 <zzz> what's the intuition here? why are w and h different?
2022-01-21 01:26:00 +0100 <ephemient> h = let k :: Num a => (a, a); k = x in (fst k, snd k) would behave like w, I expect
2022-01-21 01:26:17 +0100cyphase(~cyphase@user/cyphase)
2022-01-21 01:27:39 +0100 <zzz> yes
2022-01-21 01:27:45 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 01:29:02 +0100 <monochrom> DMR looks at "k =" and monomorphizes it.
2022-01-21 01:29:12 +0100 <monochrom> (OK, plus the fact that Num is involved.)
2022-01-21 01:29:14 +0100 <zzz> but let k :: (Num a, Num b) => (a, b); ... errrs
2022-01-21 01:29:40 +0100 <zzz> *errors
2022-01-21 01:29:52 +0100 <monochrom> Because (Num a, Num b) => (a, b) is more general than the type of x.
2022-01-21 01:30:15 +0100 <zzz> that's what trips me
2022-01-21 01:30:21 +0100 <zzz> k = x is ok
2022-01-21 01:30:21 +0100dut(~dut@user/dut)
2022-01-21 01:30:45 +0100 <monochrom> I don't know. Suppose I define "f :: () -> (); f x = x".
2022-01-21 01:31:02 +0100 <monochrom> Now suppose you use "f True".
2022-01-21 01:31:56 +0100 <ephemient> if you give them different names, there's x@Int, x@Float, and w = (fst x, snd x) is (fst x@Int, snd x@Float). two different values. whereas there is no way to fit x into (Num a, Num b) => (a, b)
2022-01-21 01:31:57 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 240 seconds)
2022-01-21 01:31:57 +0100 <monochrom> "x = what" doesn't matter, "x :: Num a => (a,a)" does.
2022-01-21 01:33:26 +0100 <zzz> hmm
2022-01-21 01:35:45 +0100 <monochrom> "let (a,b) =" and "case of (a,b)" are type-checked very differently, if that's what you're wondering.
2022-01-21 01:35:57 +0100 <monochrom> and "\(a,b) ->" is on the case side, for that matter.
2022-01-21 01:36:30 +0100 <zzz> no problem with those
2022-01-21 01:36:53 +0100 <zzz> let (a,b) = x === let a = fst x; b = snd x
2022-01-21 01:36:58 +0100 <zzz> and
2022-01-21 01:37:18 +0100 <Axman6> Guest24: so do you understand the function you have now?
2022-01-21 01:37:27 +0100 <Guest24> yes i do thank you
2022-01-21 01:37:57 +0100xff0x(~xff0x@2001:1a81:5280:6800:a068:90b7:b174:1f03) (Ping timeout: 240 seconds)
2022-01-21 01:38:06 +0100 <zzz> f = case x of (a,b) -> (a,b) === f = let ab = x in ab === h = x
2022-01-21 01:38:37 +0100 <zzz> i mean
2022-01-21 01:38:56 +0100 <zzz> === f (a,b) = (a,b) -- to be precise
2022-01-21 01:39:01 +0100xff0x(~xff0x@2001:1a81:5280:6800:582b:a2d3:42a2:2b48)
2022-01-21 01:39:57 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 01:40:36 +0100 <zzz> but why f = let k = x in (fst k, snd k) differs from f = (fst x, snd x) is not intuitive
2022-01-21 01:43:20 +0100 <ephemient> because GHC won't infer k to be polymorphic by default
2022-01-21 01:43:21 +0100 <EvanR> "let polymorphism"
2022-01-21 01:43:34 +0100 <EvanR> let generalization
2022-01-21 01:43:58 +0100 <EvanR> things I wish I knew when I learned haskell
2022-01-21 01:44:02 +0100 <johnjaye> should i worry about a difference of 8.6 vs 8.7 with ghc?
2022-01-21 01:44:17 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 240 seconds)
2022-01-21 01:45:00 +0100 <monochrom> I just tried. Those two f's do not differ.
2022-01-21 01:45:27 +0100 <EvanR> oh it's the original x
2022-01-21 01:46:47 +0100mvk(~mvk@2607:fea8:5cdd:f000::55f8)
2022-01-21 01:47:05 +0100 <zzz> monochrom: the first f requires NoMonomorphismRestriction when x :: Num a => (a,a)
2022-01-21 01:47:18 +0100 <zzz> the second one doesn't
2022-01-21 01:47:28 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Remote host closed the connection)
2022-01-21 01:47:42 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881)
2022-01-21 01:47:48 +0100 <monochrom> Sigh.
2022-01-21 01:48:01 +0100perrierjouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca) (Quit: WeeChat 3.4)
2022-01-21 01:48:33 +0100 <zzz> i may be misunderstanding you. am i missing something?
2022-01-21 01:49:50 +0100slowtyper(~slowtyper@user/slowtyper) (Ping timeout: 252 seconds)
2022-01-21 01:50:02 +0100 <ephemient> https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/let_generalisation.html MonoLocalBinds is default enabled, separately from MonomorphismRestriction
2022-01-21 01:50:27 +0100 <monochrom> https://paste.tomsmeding.com/ziRW5SJd
2022-01-21 01:50:30 +0100slowtyper(~slowtyper@user/slowtyper)
2022-01-21 01:50:31 +0100 <ephemient> actually hmm. I'm not sure what the default state is.
2022-01-21 01:51:40 +0100 <monochrom> The default state depends on other extensions, I think GADTs is an example.
2022-01-21 01:51:41 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Remote host closed the connection)
2022-01-21 01:51:54 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881)
2022-01-21 01:52:21 +0100 <geekosaur> yes
2022-01-21 01:53:15 +0100 <geekosaur> "The extension MonoLocalBinds is implied by TypeFamilies and GADTs."
2022-01-21 01:53:30 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 01:53:30 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 01:53:30 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 01:53:34 +0100 <monochrom> And I wish the pair is called PolyLocalBinds and NoPolyLocalBinds :)
2022-01-21 01:53:35 +0100 <zzz> right
2022-01-21 01:53:53 +0100perrierjouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca)
2022-01-21 01:54:57 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2022-01-21 01:58:11 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 02:01:01 +0100 <[itchyjunk]> hmm i have royally confused myself. say i have fun :: (Maybe a -> Maybe b) -> Maybe a -> b
2022-01-21 02:01:03 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 02:01:06 +0100 <[itchyjunk]> (i know its partial function)
2022-01-21 02:01:21 +0100 <[itchyjunk]> now i have `fun f (Just a ) = `
2022-01-21 02:01:35 +0100 <[itchyjunk]> i understand the lhs part of this, it's the rhs thats confusing me
2022-01-21 02:01:49 +0100 <monochrom> I think "f (Just a)" will work great?
2022-01-21 02:02:00 +0100 <monochrom> Err oops no.
2022-01-21 02:02:00 +0100 <[itchyjunk]> what i want to do it, apply f to (Just a), what i get should be `Just b`
2022-01-21 02:02:00 +0100mechano(~mechano@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net)
2022-01-21 02:02:06 +0100 <[itchyjunk]> and now i want to refrence this `b`
2022-01-21 02:02:10 +0100 <jackdk> if the input to `f` is `Maybe a`, you do not need to deconstruct it.
2022-01-21 02:02:11 +0100 <[itchyjunk]> since this is what fun should return
2022-01-21 02:02:20 +0100 <monochrom> Use moar pattern matching. Or use fromJust.
2022-01-21 02:02:28 +0100 <mechano> hi im currently using cabal and stack, but only v1 commands, what are the v2 commands for?
2022-01-21 02:02:29 +0100 <[itchyjunk]> jackdk, ah fair
2022-01-21 02:02:41 +0100 <jackdk> `fun f (Just a) = case (Just a) of { Just b -> b; Nothing -> error "I wrote a partial function and now I'm sad." }
2022-01-21 02:02:44 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 250 seconds)
2022-01-21 02:02:58 +0100 <geekosaur> mechano, cabal's v2 commands behave more like stack but without a resolver
2022-01-21 02:03:34 +0100 <geekosaur> v1 commands install things "globally" which means projects can conflict with each other by requiring incompatible versions of things. v2 prevents these collisions
2022-01-21 02:03:35 +0100 <jackdk> mechano: v1 was a lot of "seemed like a good idea" commands. prefixing the v2 commands allowed a migration path
2022-01-21 02:03:37 +0100 <mechano> also, currently installing python from the microsoft store, wondering why msi installers were depreciated in favour of chocolatey via powershell
2022-01-21 02:04:00 +0100 <mechano> jackdk: you say that in the past tense, but its the approach i use
2022-01-21 02:04:19 +0100 <geekosaur> re a real pain to use in the cloud
2022-01-21 02:04:26 +0100 <geekosaur> argh
2022-01-21 02:04:35 +0100 <mechano> geekosaur: all my v1 installs break, but i cant even do global installs with v2
2022-01-21 02:04:52 +0100 <jackdk> what cabal version are you on, and what os?
2022-01-21 02:04:53 +0100 <geekosaur> the msi question is better asked elsewhere, but I suspect it has to do with the fact that msi installers are a real pain to use in the cloud
2022-01-21 02:05:03 +0100 <mechano> if an install breaks with v1, then i use stack
2022-01-21 02:05:23 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2022-01-21 02:05:51 +0100 <mechano> geekosaur: for new users, an msi installer for ghci, cabal and stack would be useful - or via the microsoft store
2022-01-21 02:05:52 +0100larrykma(~bc8147f2@cerf.good1.com)
2022-01-21 02:06:00 +0100 <Guest24> https://paste.tomsmeding.com/NBIP3Mxa
2022-01-21 02:06:22 +0100 <jackdk> why do you want global installs? Pretty much every package ecosystem has moved away from them AFAIK (consider: project-specific node_modules dir, python venv and friends, ruby bundler, cargo...)
2022-01-21 02:06:28 +0100 <Guest24> Axman6 could you please help me with this
2022-01-21 02:06:34 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2022-01-21 02:07:20 +0100 <mechano> jackdk: win 10, ghci 9.0.1, cabal 3.4.0.0
2022-01-21 02:07:41 +0100 <geekosaur> Guest24, that looks more like javascript than haskell
2022-01-21 02:07:53 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2022-01-21 02:07:53 +0100 <geekosaur> you cannot declare a mutabloe variable with "var"
2022-01-21 02:08:01 +0100 <Guest24> i've never programmed in java
2022-01-21 02:08:03 +0100 <mechano> jackdk: because then time consuming library builds dont need to be repeated between projects
2022-01-21 02:08:12 +0100 <ephemient> Guest24: "var"??
2022-01-21 02:08:15 +0100 <glassy> https://paste.tomsmeding.com/3cbznf58 I am trying to use a partially applied class constraint as a type and define instances using that. I get that 'toBool' is not a (visible) method of class 'ToBool'.
2022-01-21 02:08:20 +0100 <glassy> what should I do to make it visible?
2022-01-21 02:08:20 +0100 <Guest24> should i use let instead
2022-01-21 02:08:36 +0100 <jackdk> they don't in v2-builds either, if the version of things is compatible
2022-01-21 02:08:46 +0100 <ephemient> Guest24: it happens to do nothing here, but I think you still have fundamental misconceptions about Haskell
2022-01-21 02:08:57 +0100 <Guest24> i definitely do
2022-01-21 02:09:21 +0100 <geekosaur> glassy, you can't use type that way
2022-01-21 02:09:32 +0100 <glassy> oh
2022-01-21 02:09:36 +0100 <glassy> what do i do instead?
2022-01-21 02:09:39 +0100 <mechano> glassy: just leave the second parameter, ie use both in the instance, but have the second as a polymorphic lowercase type
2022-01-21 02:09:46 +0100 <geekosaur> your class is called ToBoolLike, but it's looking for a class (not type synonym for a class) ToBool
2022-01-21 02:10:11 +0100 <glassy> so you can't have partially applied constraints?
2022-01-21 02:10:16 +0100 <geekosaur> you have to make the instance for ToBoolLike Bool Bool
2022-01-21 02:10:25 +0100 <mechano> dont think you an instantiate class synonyms, only use them in constraints
2022-01-21 02:10:31 +0100 <geekosaur> ^
2022-01-21 02:10:44 +0100 <glassy> ahh so it isn't possible thanks
2022-01-21 02:10:56 +0100 <geekosaur> it's not even looking at yout `type`, it's looking directly for ToBool instead of ToBoolLike
2022-01-21 02:11:10 +0100 <mechano> but whater you were trying to do should be possible using actual syntax
2022-01-21 02:11:34 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2022-01-21 02:11:34 +0100 <EvanR> Guest24, `let x = some formula here in ...' is fundamentally like substituting `some formula here' in ... wherever x appears (unless shadowed e.g. by more lets)
2022-01-21 02:11:48 +0100lechner(~lechner@debian/lechner) (Ping timeout: 256 seconds)
2022-01-21 02:11:56 +0100 <mechano> still dont get what v2 is for btw. whats the advantage instead of stack when not doing global installs?
2022-01-21 02:12:00 +0100 <EvanR> which is different from the usual way variables work
2022-01-21 02:12:06 +0100 <EvanR> in e.g. javascript
2022-01-21 02:12:59 +0100 <EvanR> it's arguably a lot easier to reason about the haskell way
2022-01-21 02:13:05 +0100 <ephemient> Guest24: the immediate issue is that you have an expression in a where block. there is a difference between bindings and expressions. at the top level or inside let or where, you can have bindings ("x = ...", "f x = ...", etc.) but not expressions ("x", "if ...", etc.). expressions go on the right-hand side of an =
2022-01-21 02:13:17 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 02:13:55 +0100 <mechano> is it advised to use stack or v2?
2022-01-21 02:14:44 +0100 <geekosaur> that's a matter of taste
2022-01-21 02:14:46 +0100 <monochrom> Both get advocates. I'm on the cabal side.
2022-01-21 02:14:53 +0100 <geekosaur> some people prefer stackk, some cabal
2022-01-21 02:14:59 +0100 <mechano> im guessing the only difference is that v2 uses the currently avaiable packages and the currently installed ghc
2022-01-21 02:15:23 +0100 <glassy> mechano it works just using ToBoolLike Bool t, although I had a typo t and b were in the wrong order on line 9
2022-01-21 02:15:27 +0100 <Guest24> https://paste.tomsmeding.com/eH12euPM
2022-01-21 02:15:31 +0100 <mechano> why were global installs depreciated?
2022-01-21 02:15:34 +0100 <glassy> it compiles although i'm scared
2022-01-21 02:15:35 +0100 <monochrom> I disbelieve in stackage, and I disbelieve in auto-installing yet another version of GHC, so I chose cabal.
2022-01-21 02:15:41 +0100 <glassy> it requires undecidable instances
2022-01-21 02:15:45 +0100 <geekosaur> mechano, they conflict with each other
2022-01-21 02:15:54 +0100 <Guest24> this is what i've changed from what I understand of what you said ephemient
2022-01-21 02:16:03 +0100 <geekosaur> stack and cabal v2 both refuse to do global installs for that reason
2022-01-21 02:16:15 +0100 <monochrom> You have experienced breaks under v1. It is why.
2022-01-21 02:16:19 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 02:16:24 +0100 <mechano> glassy: this is a very useful langage extension, its basically on all the time if your doiing anything
2022-01-21 02:16:39 +0100 <EvanR> the problem with global installs is the same as earlier, they didn't go far enough and have some server with the latest working GHC available for anyone in the world to use. A global install
2022-01-21 02:16:45 +0100 <geekosaur> they both install to internal repositories anbd expose parts of those repositories specifically when requested, as opposed to always (and causing conflicts)
2022-01-21 02:16:55 +0100 <mechano> it should probably have a less scary name...
2022-01-21 02:16:57 +0100 <glassy> yeah but usually it is other people's code that i turn on undecidable instances for
2022-01-21 02:16:59 +0100 <glassy> not my own haha
2022-01-21 02:17:02 +0100 <monochrom> or s/breaks/conflicts/
2022-01-21 02:17:12 +0100 <ephemient> Guest24: ok. now you have two expressions: if then else; if then else. that's not something that makes sense in Haskell
2022-01-21 02:17:33 +0100 <mechano> monochrom: i guess i like stack because im sick of my hard work getting bitrotten
2022-01-21 02:17:35 +0100 <Guest24> ok should have nested if then else or quards or something
2022-01-21 02:17:41 +0100albet70(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2022-01-21 02:18:00 +0100 <glassy> my problem with stack is i always end up with multiple stack versions for different projects
2022-01-21 02:18:03 +0100 <glassy> but that is probably just me
2022-01-21 02:18:09 +0100 <monochrom> cabal v2 has "cabal freeze" to mitigate that.
2022-01-21 02:18:19 +0100 <ephemient> (well, in theory you could have (if then else) (if then else) the first r function applied to an argument, both of which come from conditionals, but the syntax doesn't allow for that without grouping)
2022-01-21 02:18:35 +0100 <monochrom> It's like a huge generalization of stackage resolver.
2022-01-21 02:18:37 +0100Neuromancer(~Neuromanc@user/neuromancer) (Ping timeout: 240 seconds)
2022-01-21 02:18:37 +0100 <jackdk> using correct version bounds on deps also avoids this problem - see `cabal gen-bounds` as a starting point
2022-01-21 02:18:47 +0100 <ephemient> Guest24: yes. and then once you figure that out, you'll find that "== Special String" doesn't work either.
2022-01-21 02:18:49 +0100 <mechano> so if two imports use different version of the same library, it gets both and just sends the parts where they are needed?
2022-01-21 02:18:57 +0100machinedgod(~machinedg@24.105.81.50)
2022-01-21 02:18:58 +0100 <ephemient> to deconstruct data constructors, use pattern matching
2022-01-21 02:19:23 +0100 <monochrom> Yeah and cabal gen-bounds.
2022-01-21 02:19:43 +0100 <ephemient> == is not a pattern match. f (Special _) is, as is case _ of Special _ ->; ...
2022-01-21 02:20:02 +0100 <mechano> so stack is basically superceded entierly by v2? what about breaking ghci changes? is that the only case where saving a copy with the stack resolver would be an extra layer of safety?
2022-01-21 02:20:23 +0100 <mechano> i cant see how v2 freeze could match that without the local ghci installs
2022-01-21 02:20:35 +0100ec(~ec@gateway/tor-sasl/ec) (Quit: ec)
2022-01-21 02:20:49 +0100 <monochrom> Right, I would still need to keep my old GHC around.
2022-01-21 02:20:57 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 240 seconds)
2022-01-21 02:21:04 +0100 <ephemient> mechano: I can only parse your sentence in a way that makes a modicum of sense with s/ghci/ghc
2022-01-21 02:21:15 +0100 <mechano> yeah that was a type
2022-01-21 02:21:18 +0100 <mechano> typo*
2022-01-21 02:21:21 +0100 <ephemient> but yeah, if you're using cabal just keep multiple ghc's around with ghcup
2022-01-21 02:21:28 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-21 02:21:35 +0100DNH(~DNH@2a02:8108:1100:16d8:7985:a982:d93:11f) (Quit: Textual IRC Client: www.textualapp.com)
2022-01-21 02:21:36 +0100 <mechano> but stack does all that...
2022-01-21 02:21:39 +0100 <glassy> when i use cabal build -j24 it doesn't peg all my cores but rather just one?
2022-01-21 02:21:43 +0100 <glassy> why is that?
2022-01-21 02:21:46 +0100 <monochrom> Frankly I don't mind updating my code for a newer GHC and some newer versions of libraries.
2022-01-21 02:21:47 +0100 <mechano> and it records which is the right ghc for the old libs
2022-01-21 02:21:52 +0100 <davean> mechano: stack does a very limited special case of that
2022-01-21 02:22:01 +0100 <mechano> limited!?
2022-01-21 02:22:05 +0100 <davean> Extremely
2022-01-21 02:22:15 +0100 <mechano> seems to do it perfectly, whats the criticism for?
2022-01-21 02:22:28 +0100 <davean> Try targetting something other than your current system
2022-01-21 02:22:39 +0100 <davean> like JS or webassembly, or crosscompilation, or ...
2022-01-21 02:22:40 +0100 <monochrom> So if you mind that very much and try to argue with me, we won't get anywhere. I do my thing.
2022-01-21 02:22:42 +0100 <mechano> so v2 does cross compliation?
2022-01-21 02:23:21 +0100 <mechano> monochrom: im arguing that stack is the only way to ensure builds do not become bitrotten
2022-01-21 02:23:26 +0100 <davean> Its GHC that does the cross compilation
2022-01-21 02:23:44 +0100 <mechano> im asking why i should use v2
2022-01-21 02:23:56 +0100 <ephemient> because v1 is dead
2022-01-21 02:23:57 +0100 <davean> mechano: If you're arguing that you're just here trolling and I'm done?
2022-01-21 02:24:11 +0100 <monochrom> I know a prof who explained an even better way.
2022-01-21 02:24:14 +0100 <jackdk> in fact, stack does a great job of encouraging bitrot, as its templates create libraries with no bounds on deps, which then get uploaded to hackage and break things for everyone else
2022-01-21 02:24:20 +0100 <mechano> you wade in quite rudely davean
2022-01-21 02:24:29 +0100 <monochrom> But it involves keeping even the old hardware.
2022-01-21 02:24:47 +0100 <monochrom> And he didn't even have Haskell in mind. More likely C.
2022-01-21 02:24:53 +0100 <EvanR> I'd appreciate a stackage for old hardware
2022-01-21 02:25:02 +0100 <mechano> jackdk: ah, i wasnt aware of this issue to do with bounds
2022-01-21 02:25:04 +0100 <jackdk> Particular recent example: base >= 4.x && <5 admits unreleased versions which are allowed to contain breaking changes, which is exactly what happened when GHC9 appeared on the scene
2022-01-21 02:25:08 +0100 <jackdk> also aeson-2.0
2022-01-21 02:25:20 +0100 <johnjaye> ephemient: what is the difference between v1 and v2 in cabal? i saw a makefile that was talking about v1 commands
2022-01-21 02:25:22 +0100 <EvanR> operator, get me an old BeBox, for R5
2022-01-21 02:25:33 +0100 <glassy> i thought v2 had atomic updates and stuff like that?
2022-01-21 02:25:38 +0100 <glassy> i'm probably wrong
2022-01-21 02:25:42 +0100 <Guest24> could i put an if statement within an if statement
2022-01-21 02:25:43 +0100 <davean> glassy: that -j is the package parallization, not the GHC
2022-01-21 02:25:54 +0100 <glassy> what do you mean by package parallization?
2022-01-21 02:26:03 +0100 <monochrom> His way translated to Haskell, you wouldn't even refer to stackage online. You would download the tarballs, and stick to them. You don't even know that stackage won't change the tarballs.
2022-01-21 02:26:12 +0100 <jackdk> so I consider the patterns encouraged by stack to be extremely rude, in that they use the bounds information to construct their snapshots, and then encourage the uploading of packages which make that break that information source.
2022-01-21 02:26:25 +0100 <davean> glassy: compiling seperate packages in parallel, not inside a package
2022-01-21 02:26:39 +0100 <davean> glassy: and most of cabal stuff is atomic - what do you mean by atomic updates?
2022-01-21 02:26:43 +0100 <ephemient> my approximate flowchart is: stack is fine if you just want some libraries as an end-product and don't particularly care which versions. cabal is required if you want to stay up to date or ship something to be used by other users
2022-01-21 02:27:01 +0100 <glassy> i just thought you could rollback stuff with cabal v2, i'm not well informed
2022-01-21 02:27:12 +0100 <davean> glassy:
2022-01-21 02:27:24 +0100 <davean> The concept of "rollback" isn't meaningful for v2
2022-01-21 02:27:54 +0100 <jackdk> I can respect that it helps people making applications at the leaf of the dependency graph, but it also holds the ecosystem back. There's little enthusiasm for using things like backpack and multiple internal libraries because they don't work with stack, and stack has not enough dev resources
2022-01-21 02:27:57 +0100 <mechano> jackdk: hmm, so it doesnt ensure against breaking changes from new ghc versions. thats a shame, since that was the reason i was using it. i guess if it doesnt even do that, then my reason for using it, and advocating for it, and the haskell toolchain - based on a rationality of the snapshots ... wait, how does what you say change anything, the
2022-01-21 02:27:57 +0100 <mechano> snapshots should always use the correct ghc
2022-01-21 02:28:04 +0100 <glassy> lol idk
2022-01-21 02:28:28 +0100 <glassy> davean: how do i make builds inside a package parallel as well as compiling seperate packages in parallel?
2022-01-21 02:28:42 +0100 <glassy> been wondering for about a year embarassingly
2022-01-21 02:28:53 +0100 <glassy> maybe i got it working but my disk is the bottleneck
2022-01-21 02:28:58 +0100 <Guest24> https://paste.tomsmeding.com/6yumtqfg
2022-01-21 02:29:24 +0100 <Guest24> this is what I've changed
2022-01-21 02:30:04 +0100 <dibblego> it's Friday somewhere, go to the pub
2022-01-21 02:30:05 +0100 <jackdk> mechano: maybe the snapshots continue to work. That's not what I'm saying. I'm saying that the patterns encouraged by stack encourage people to submit misbehaving libraries to hackage, which makes the ecosystem worse for everyone else. I don't support bootstrapping off someone else's commons, and then making it worse
2022-01-21 02:30:08 +0100 <davean> glassy: Also, is your setup a custom setup?
2022-01-21 02:30:10 +0100 <mechano> ephemient: as far as i could tell it was the only way to ensure that a personal project that builds could certainly be built again at another time
2022-01-21 02:30:31 +0100 <glassy> davean no, it is just cabal now after i moved from stack
2022-01-21 02:30:37 +0100 <glassy> i don't have any dot files changing compilation
2022-01-21 02:30:54 +0100vysn(~vysn@user/vysn)
2022-01-21 02:31:19 +0100 <jackdk> besides, who knows if the ghc you download will run against the system libs on your build machine in the future? Nix will get you closer, but this question will ultimately bottom out against the fact that GHC doesn't have a working bootstrap path any more
2022-01-21 02:31:28 +0100 <monochrom> dibblego: But the pubs are closed in my city :(
2022-01-21 02:31:33 +0100 <davean> glassy: see https://gitlab.haskell.org/ghc/ghc/-/merge_requests/5176
2022-01-21 02:31:38 +0100 <dibblego> can't be, that's illegal
2022-01-21 02:31:58 +0100 <davean> glassy: if you have parallism between package builds - the strongest parallelism - then you have a problem of getting the correct overall parallelism when there is parallelism inside a build
2022-01-21 02:32:04 +0100 <ephemient> mechano: cabal can certainly pin versions, including ghc. the onus is on you to have a working GHC version, but I think that's reasonable: ghcup makes it easy
2022-01-21 02:32:23 +0100 <glassy> i've tried using ghc-options -j 24 too
2022-01-21 02:32:43 +0100 <glassy> it is hard to know how to split threads between building packages and those packages themselves
2022-01-21 02:32:45 +0100 <ephemient> I still use stack for personal projects, but I'm sort of expecting to have to switch off of it as it's in community maintenance mode now
2022-01-21 02:32:46 +0100incertia(~incertia@24.42.241.219) (Ping timeout: 256 seconds)
2022-01-21 02:33:04 +0100 <mechano> ah, i understand your point now jackdk
2022-01-21 02:33:06 +0100 <mechano> seems fair
2022-01-21 02:33:22 +0100 <johnjaye> jackdk: i'm kinda new to haskell so i don't really get how cabal works
2022-01-21 02:33:34 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 02:33:34 +0100 <johnjaye> i just use it to install things with cabal install. i guess that's bad because of library versions?
2022-01-21 02:34:01 +0100 <Guest24> https://paste.tomsmeding.com/ZKBIf4iv
2022-01-21 02:34:04 +0100 <mechano> ephemient: pin? iv never written the ghc version in a cabal file, i guess i should do that instead of using stack?
2022-01-21 02:34:16 +0100 <Guest24> i get an error with the special string
2022-01-21 02:34:26 +0100 <Guest24> how do i fix it :((
2022-01-21 02:34:40 +0100 <monochrom> See this is why my prof says to even keep old hardware. Keep old hardware. Keep old OS. Keep old system libs...
2022-01-21 02:35:00 +0100 <ephemient> mechano: https://cabal.readthedocs.io/en/3.6/cabal-project.html#cfg-field-with-compiler
2022-01-21 02:35:12 +0100 <johnjaye> monochrom: there is potential wisdom in that. the problem is you don't know which old hardware or OS will end up being useful. exponential and all
2022-01-21 02:35:12 +0100Kaiepi(~Kaiepi@156.34.47.253) (Read error: Connection reset by peer)
2022-01-21 02:35:17 +0100 <ephemient> I don't know if I'd say "should"; it will depend on your priorities.
2022-01-21 02:35:21 +0100 <monochrom> He was teaching a software engineering course and was relating actual practices in very large companies.
2022-01-21 02:36:09 +0100 <monochrom> A glimpse of his context is in "we're talking about a million lines of code".
2022-01-21 02:36:11 +0100 <mechano> ok cool, so i just write the with-compiler line in the cabal file. ok, i guess i dont need to use stack
2022-01-21 02:36:24 +0100 <monochrom> Although, a million lines of C is not doing very much.
2022-01-21 02:36:34 +0100 <ephemient> * not the project.cabal file, but the cabal.project file
2022-01-21 02:36:50 +0100 <jackdk> johnjaye: generally I'm working in some package, so I list the packages I need in `build-depends` and go from there
2022-01-21 02:37:13 +0100 <mechano> ephemient: oh thanks, i didnt spot that
2022-01-21 02:37:14 +0100 <johnjaye> monochrom: well if your self-driving car crashes due to a bug just restart and recompile
2022-01-21 02:37:43 +0100 <jackdk> johnjaye: if you just want to test some stuff in a repl it's possible to say `cabal repl -b lens`, say
2022-01-21 02:38:01 +0100 <mechano> johnjaye: the good thing is that now that tesla has such a large cluster with convolutional geometry, that my old "structured access memory" patterns are finally useful
2022-01-21 02:38:10 +0100 <Guest24> ephemient the special string doesn't work could you please look at my code https://paste.tomsmeding.com/ZKBIf4iv
2022-01-21 02:38:16 +0100alp(~alp@user/alp) (Ping timeout: 250 seconds)
2022-01-21 02:38:20 +0100ec(~ec@gateway/tor-sasl/ec) (Quit: ec)
2022-01-21 02:38:26 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 256 seconds)
2022-01-21 02:38:33 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-21 02:38:36 +0100 <ephemient> like I mentioned earlier, "== Special String" is not the way to pattern match
2022-01-21 02:38:43 +0100 <mechano> instead of having to emulate it with fpga's
2022-01-21 02:39:13 +0100 <ephemient> you can pattern match when binding (the left-hand side of =, or "case ... of")
2022-01-21 02:39:56 +0100 <mechano> does anyone remember that? the thing with the pointer comonads for nearest neighbour navigation...
2022-01-21 02:39:56 +0100slac83129(~slack1256@186.11.27.69)
2022-01-21 02:39:57 +0100 <ephemient> that being said, the error message is rightfully about String - you're trying to use it in a value position, but there is no "value" named "String"
2022-01-21 02:40:26 +0100 <ephemient> there's basically a namespace for types and a namespace for values, and "String" is only in the former
2022-01-21 02:40:28 +0100 <davean> glassy: yah well ... uh, you're going to have problems getting -j to GHC to work - never mind it might just not be possible with your project due to include order
2022-01-21 02:40:32 +0100 <Guest24> https://paste.tomsmeding.com/7TOb0tPp this is what i've changed it to
2022-01-21 02:40:38 +0100 <monochrom> I think I remember people implementing Game of Life with comonads...
2022-01-21 02:40:49 +0100 <mechano> right, but its slow without SAM
2022-01-21 02:40:50 +0100 <ephemient> Guest24: still not a binding
2022-01-21 02:41:02 +0100 <Guest24> what is a binding
2022-01-21 02:41:07 +0100 <ephemient> the left-hand side of =
2022-01-21 02:41:15 +0100 <monochrom> Oh, I also heard of transputers...
2022-01-21 02:41:25 +0100 <mechano> lol
2022-01-21 02:41:29 +0100 <jackdk> monochrom: that's the main use of seen, as well as buildery configuration things using `instance Monoid m => Comonad ((->) m)`
2022-01-21 02:41:32 +0100 <ephemient> (eh... more complicated than that but close enough for now)
2022-01-21 02:42:01 +0100 <davean> mechano: theres a lot of optimization approaches to the comonad code, the nice part is the optimizations are externally applied
2022-01-21 02:42:03 +0100 <mechano> idk why they call it "bind" - makes it seem like some kind of paradox infliction
2022-01-21 02:42:19 +0100 <Guest24> what would i bind that to tho
2022-01-21 02:42:24 +0100slack1256(~slack1256@191.125.99.215) (Ping timeout: 256 seconds)
2022-01-21 02:42:26 +0100 <jackdk> a name gets bound to an expression or value, I guess
2022-01-21 02:42:29 +0100zaquest(~notzaques@5.130.79.72)
2022-01-21 02:42:48 +0100 <davean> mechano: because it attaches a name to a definition
2022-01-21 02:42:53 +0100 <mechano> i guess its because >>= puts the output into the rhs for lambda binding or something
2022-01-21 02:43:06 +0100 <ephemient> that's "bind" but a different one
2022-01-21 02:43:17 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net) (Ping timeout: 240 seconds)
2022-01-21 02:43:52 +0100 <mechano> yeah, things end up confused because of these semantics
2022-01-21 02:43:58 +0100 <monochrom> Perhaps it's a LoTR Mordor one-ring reference :)
2022-01-21 02:44:33 +0100 <davean> I mean its sorta the same bind/apply thing, sorta
2022-01-21 02:44:40 +0100 <monochrom> "one doesn't simply extract from Mordor" or something...
2022-01-21 02:45:03 +0100 <monochrom> CoMordor, though, is a different story...
2022-01-21 02:45:21 +0100 <davean> monochrom: CoMordor allows the eagel operator
2022-01-21 02:45:27 +0100 <monochrom> :)
2022-01-21 02:45:33 +0100 <mechano> i thought that was a metaphor for promises
2022-01-21 02:46:35 +0100 <mechano> bound to be..
2022-01-21 02:46:37 +0100zmt01(~zmt00@user/zmt00)
2022-01-21 02:47:30 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 02:47:54 +0100mechano(~mechano@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net) (Quit: Connection closed)
2022-01-21 02:48:11 +0100 <monochrom> Haha
2022-01-21 02:48:52 +0100 <EvanR> Unforunately, no one can be told what a Monad is :morpheus:
2022-01-21 02:49:17 +0100zmt00(~zmt00@user/zmt00) (Ping timeout: 240 seconds)
2022-01-21 02:49:39 +0100 <monochrom> Is Neo ()? Or is Neo IO()?
2022-01-21 02:50:01 +0100ub(~Thunderbi@p548c8cd6.dip0.t-ipconnect.de)
2022-01-21 02:50:21 +0100larrykma(~bc8147f2@cerf.good1.com) (Quit: CGI:IRC (Ping timeout))
2022-01-21 02:51:16 +0100ubert(~Thunderbi@p200300ecdf0994402d77270a91cab57e.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2022-01-21 02:51:17 +0100ububert
2022-01-21 02:52:18 +0100 <EvanR> well I guess they escape from The Matrix after all so that parallel is dead
2022-01-21 02:52:24 +0100 <ephemient> neo = the [1, 1..]
2022-01-21 02:52:36 +0100 <davean> I think Neo is (# State# RealWorld, Neo #)
2022-01-21 02:53:00 +0100 <davean> He got unboxed
2022-01-21 02:55:15 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 256 seconds)
2022-01-21 02:55:15 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 02:55:59 +0100 <zzz> this is fun: https://paste.jrvieira.com/1642730131768
2022-01-21 02:58:01 +0100 <Guest24> hi so this is what i decided to bind could it be correct ??
2022-01-21 02:58:03 +0100 <Guest24> ghci> :l question4
2022-01-21 02:58:04 +0100 <Guest24> [1 of 1] Compiling Shop ( question4.hs, interpreted )
2022-01-21 02:58:04 +0100 <Guest24> question4.hs:16:1: warning: [-Wtabs]
2022-01-21 02:58:05 +0100 <Guest24>     Tab character found here, and in 10 further locations.
2022-01-21 02:58:05 +0100 <Guest24>     Please use spaces instead.
2022-01-21 02:58:06 +0100 <Guest24>    |
2022-01-21 02:58:06 +0100 <Guest24> 16 | (if f (Special String) == True
2022-01-21 02:58:07 +0100 <Guest24>    | ^^^^^^^^
2022-01-21 02:58:07 +0100 <Guest24> question4.hs:25:1: error: parse error on input `totalBanana'
2022-01-21 02:58:08 +0100 <Guest24>    |
2022-01-21 02:58:08 +0100 <Guest24> 25 | totalBanana :: [IceCream] -> Float
2022-01-21 02:58:09 +0100 <Guest24>    | ^^^^^^^^^^^
2022-01-21 02:58:09 +0100 <Guest24> Failed, no modules loaded.
2022-01-21 02:58:10 +0100 <Guest24> ghci>
2022-01-21 02:58:12 +0100 <Guest24> https://paste.tomsmeding.com/rvkscpSB
2022-01-21 02:58:34 +0100 <Guest24> i'm sorry i thought i had copied the URL but i still had the error message
2022-01-21 02:58:35 +0100 <zzz> Guest24: try not to do that
2022-01-21 02:58:47 +0100 <zzz> Guest24: which irc client are you using?
2022-01-21 02:58:55 +0100 <Guest24> irc client?
2022-01-21 02:59:55 +0100 <jackdk> looks like the libera web interface whatever that is
2022-01-21 03:00:16 +0100 <zzz> yes. which program are you using to access irc? you can configure most to prevent long pastes
2022-01-21 03:00:25 +0100 <zzz> jackdk: oh well :/
2022-01-21 03:01:10 +0100 <Guest24> im using windows powershell and editting with motepad ++ but that's all I know
2022-01-21 03:01:37 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 03:02:38 +0100califax-(~califax@user/califx)
2022-01-21 03:03:06 +0100 <Guest24> could someone please help me with my code ?
2022-01-21 03:03:08 +0100 <Axman6> where you're taling right now is IRC Guest24, are you doing that in a browser?
2022-01-21 03:03:24 +0100 <Guest24> https://paste.tomsmeding.com/rvkscpSB
2022-01-21 03:03:59 +0100 <zzz> well, i guess my paste is going to go unnoticed...
2022-01-21 03:04:03 +0100 <Axman6> Guest24: you can't indent those definitions like that, all top level definitions need to start in the first column
2022-01-21 03:04:27 +0100 <Guest24> the definitions as in the types
2022-01-21 03:04:41 +0100 <Axman6> module isn;t an object of some sort, it';s the name for a collection of definitions
2022-01-21 03:05:06 +0100 <Axman6> you also need to configure your text editor to not use tabs
2022-01-21 03:05:25 +0100 <monochrom> Axman6, that was partly my fault, I wrongly suggested the indenting. Although, I also thought I already said I was wrong.
2022-01-21 03:05:31 +0100alp(~alp@user/alp)
2022-01-21 03:05:32 +0100 <Axman6> that will fix the first warning, to fix the error, you need to remove the spaced before the words type and data
2022-01-21 03:05:39 +0100califax(~califax@user/califx) (Ping timeout: 276 seconds)
2022-01-21 03:05:40 +0100califax-califax
2022-01-21 03:06:17 +0100 <Axman6> spaces*
2022-01-21 03:06:33 +0100 <Axman6> thank god I don't work in an industry where typing is my main activity! >_<
2022-01-21 03:07:03 +0100 <Guest24> https://paste.tomsmeding.com/hs4fwq8S
2022-01-21 03:08:10 +0100 <Axman6> there is a lot wrong with the line "isBanana if (f,s,h) == Banana"
2022-01-21 03:08:19 +0100 <Axman6> firstly, there's no = so it is not a definition'
2022-01-21 03:09:25 +0100 <Axman6> seccondly, (f,s,h) has type (Flavour, Scoops, HasSprinkles) but Banana has type Flavour, so you can't test if they are equal, only things of the same type can be equsl
2022-01-21 03:09:53 +0100 <Axman6> start with: isBanana (f,s,h) = <definition of the function>
2022-01-21 03:10:43 +0100 <Axman6> price's definition also doesn't make sense, you've said its type is IceCream -> Float, but in price [] = 0 you're saying that the first argument is a list
2022-01-21 03:10:56 +0100 <Axman6> you should delete that line
2022-01-21 03:11:49 +0100 <zzz> Guest24: how are you introducing yourself to Haskell? Are you following any specific material?
2022-01-21 03:12:02 +0100 <Axman6> also, you should stop writing x == True, it is always redundant, eithe x is True and the result is True, or x is False and the result is False.
2022-01-21 03:12:21 +0100 <Guest24> https://paste.tomsmeding.com/gmqbZeSd
2022-01-21 03:12:34 +0100 <Guest24> this is what i've done
2022-01-21 03:13:17 +0100 <Guest24> should i use case of instead if statements in the price function
2022-01-21 03:13:43 +0100 <Axman6> yes, that would be much clearer
2022-01-21 03:13:59 +0100 <Guest24> ok i'll try that
2022-01-21 03:14:14 +0100 <Guest24> do the other things look ok to you when it comes to my program
2022-01-21 03:14:28 +0100 <zzz> this desn't seem like the best approach to learning a language
2022-01-21 03:14:30 +0100 <Guest24> i think i may still have an issue with my totalscoops function
2022-01-21 03:15:49 +0100 <Axman6> Guest24: explain what you think "s + (f,s,h):xs" is doing?
2022-01-21 03:16:02 +0100 <ephemient> 1. the precedence of + and : does not lead to expected results in totalScoops, and 2. your recursion does not make any progress
2022-01-21 03:16:55 +0100 <ephemient> but 0. you're still using ==; Flavor is not an Eq so that won't work. also that is not what you want to do for Special anyway.
2022-01-21 03:17:09 +0100 <zwro[m]> zzz: why does that happen?
2022-01-21 03:17:14 +0100 <zzz> why does what happen?
2022-01-21 03:17:54 +0100 <zwro[m]> <zzz> "this is fun: https://paste...." <- https://paste.jrvieira.com/1642730131768
2022-01-21 03:19:02 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.4)
2022-01-21 03:19:24 +0100jacks2(~bc8147f2@217.29.117.252)
2022-01-21 03:21:51 +0100tolt(~weechat-h@li219-154.members.linode.com) (Quit: WeeChat 2.9)
2022-01-21 03:22:21 +0100 <zzz> i'm not sure
2022-01-21 03:23:57 +0100neurocyte0917090(~neurocyte@user/neurocyte) (Ping timeout: 240 seconds)
2022-01-21 03:24:21 +0100 <EvanR> if F is some type family and I have an a -> b, can I have a F a -> F b
2022-01-21 03:24:32 +0100 <EvanR> guess not
2022-01-21 03:24:40 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 03:25:04 +0100 <Guest24> https://paste.tomsmeding.com/ShhEzeE5
2022-01-21 03:25:25 +0100 <Guest24> i still am not sure how creat recursive functions
2022-01-21 03:25:47 +0100tolt(~weechat-h@li219-154.members.linode.com)
2022-01-21 03:26:13 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2022-01-21 03:26:51 +0100 <jackdk> EvanR: you would need an instance of that type family `F (a -> b) = F a -> F b`
2022-01-21 03:27:07 +0100 <ephemient> Guest24: you were close before, you just had some extra bits breaking it
2022-01-21 03:27:16 +0100 <EvanR> I have that
2022-01-21 03:27:20 +0100 <Guest24> ok thank you
2022-01-21 03:27:26 +0100 <Guest24> i'll try to figure it out again
2022-01-21 03:27:39 +0100 <EvanR> so how do I get the actual values xD
2022-01-21 03:28:45 +0100xff0x(~xff0x@2001:1a81:5280:6800:582b:a2d3:42a2:2b48) (Ping timeout: 268 seconds)
2022-01-21 03:28:54 +0100 <EvanR> I'm not sure it's possible since F a need have nothing to do with a
2022-01-21 03:30:17 +0100xff0x(~xff0x@2001:1a81:52b8:8500:a7fd:d6d9:518c:9835)
2022-01-21 03:31:43 +0100 <zwro[m]> zzz: ok that's weird
2022-01-21 03:32:00 +0100 <Guest24> https://paste.tomsmeding.com/NZ0tO7e6
2022-01-21 03:32:10 +0100 <Guest24> so this what i've gotten to so far
2022-01-21 03:32:36 +0100 <Guest24> should i use s instead of x
2022-01-21 03:33:33 +0100 <Guest24> https://paste.tomsmeding.com/d2T0W0yD
2022-01-21 03:34:00 +0100 <Guest24> so i changed it and now im getting errors for the last function
2022-01-21 03:34:12 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 03:34:23 +0100 <Guest24> ephemient
2022-01-21 03:35:16 +0100 <ephemient> filter returns a list with the same type as its input, just with fewer elements
2022-01-21 03:35:50 +0100 <ephemient> a list cannot be a Float, which is why there is a type error there
2022-01-21 03:35:56 +0100 <Guest24> ok
2022-01-21 03:35:57 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 240 seconds)
2022-01-21 03:36:09 +0100 <zwro[m]> zzz: in https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/let_generalisation.html you can read:
2022-01-21 03:36:23 +0100 <zwro[m]> So here are the exact rules used by MonoLocalBinds. With MonoLocalBinds, a binding group will be generalised if and only if
2022-01-21 03:36:23 +0100 <zwro[m]> Each of its free variables (excluding the variables bound by the group itself) is closed (see next bullet), or
2022-01-21 03:36:23 +0100 <zwro[m]> Any of its binders has a partial type signature (see Partial Type Signatures). Adding a partial type signature f :: _, (or, more generally, f :: _ => _) provides a per-binding way to ask GHC to perform let-generalisation, even though MonoLocalBinds is on.
2022-01-21 03:37:48 +0100 <zzz> zwro[m]: that doesn't explain my example. I don't think MonoLocalBinds is relevant even
2022-01-21 03:37:49 +0100jenna8912(~jenna@c-107-5-104-51.hsd1.mi.comcast.net) (Quit: Reconnecting)
2022-01-21 03:38:01 +0100jenna8912(~jenna@c-107-5-104-51.hsd1.mi.comcast.net)
2022-01-21 03:40:34 +0100 <zzz> even more, g and h both have partial type signatures on y (in fact, it's the noly diff) and the former errors while the latter works, MR or NoMR
2022-01-21 03:42:20 +0100 <Guest24> https://paste.tomsmeding.com/4wOl8H40
2022-01-21 03:42:27 +0100 <Guest24> this what i've done
2022-01-21 03:42:39 +0100 <Guest24> i've made the function recursive like the top one
2022-01-21 03:43:12 +0100 <zwro[m]> zzz: it's weird. i have no idea what's going on there. maybe _ -> allows for ghc to generalize it to Any -> ? but I'm out of my depth
2022-01-21 03:43:59 +0100 <zzz> zwro[m]: that seems unlikely
2022-01-21 03:45:09 +0100 <ephemient> pretty sure _ => _ forces it to be polymorphic, bypassig MR
2022-01-21 03:45:25 +0100 <ephemient> while _ doesn't
2022-01-21 03:46:46 +0100 <zzz> ephemient: can you suggest some literature where i can explore this further?
2022-01-21 03:47:27 +0100 <zzz> why does _ fail then?
2022-01-21 03:48:07 +0100 <ephemient> because there's no _ that can stand in, that one is definitely monomorphic
2022-01-21 03:48:16 +0100 <ephemient> at least, that's how it looks; I've never played with PartialTypeSignatures before
2022-01-21 03:48:59 +0100 <zzz> ah, (a,b) would clash with Num a => (a,a)
2022-01-21 03:49:26 +0100razetime(~quassel@49.207.203.87)
2022-01-21 03:50:01 +0100 <zzz> wait
2022-01-21 03:50:06 +0100 <zzz> hmm
2022-01-21 03:50:12 +0100jacks2(~bc8147f2@217.29.117.252) (Quit: http://www.okay.uz/)
2022-01-21 03:50:38 +0100 <zzz> y :: (a,b) gives me:
2022-01-21 03:50:38 +0100 <zzz> Expected type: (a, b)
2022-01-21 03:50:38 +0100 <zzz> Actual type: (a, a)
2022-01-21 03:50:45 +0100 <zzz> :/
2022-01-21 03:50:53 +0100 <zzz> but i get it
2022-01-21 03:51:04 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2022-01-21 03:51:04 +0100ncopa3(~ncopa@gbr2-dev1.alpinelinux.org) (Remote host closed the connection)
2022-01-21 03:51:37 +0100 <ephemient> further evidence: () => _ fails, so the _ => definitely makes the difference
2022-01-21 03:51:41 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2022-01-21 03:52:57 +0100 <monochrom> zzz: Here you run into "y :: (a,b)" meaning "y :: forall t1 t2. (t1, t2)" and has nothing to do with any outer "a" or "b". And then you will read up on ScopedTypeVariables.
2022-01-21 03:54:44 +0100 <zzz> monochrom: you are right, i forgot about the implicit forall
2022-01-21 03:55:31 +0100 <zzz> might be room for error message imporvement
2022-01-21 03:55:33 +0100 <monochrom> Isn't Haskell exciting! >:)
2022-01-21 03:55:49 +0100 <zzz> i's pretty confusing, but rewarding noneheless
2022-01-21 03:56:57 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2022-01-21 03:57:44 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2022-01-21 03:58:37 +0100 <zzz> learning haskell is like reading a contract with recursive fineprint
2022-01-21 03:58:44 +0100 <monochrom> Consider conflating "exciting" with "surprising" haha
2022-01-21 03:59:57 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 240 seconds)
2022-01-21 04:00:54 +0100 <zzz> at some point i started expecting the "surprise"
2022-01-21 04:01:27 +0100 <ski> @quote is.the.solution
2022-01-21 04:01:27 +0100 <lambdabot> quicksilver says: head-explosion is the solution, not the problem.
2022-01-21 04:01:49 +0100 <zzz> ski: :)
2022-01-21 04:02:23 +0100 <ephemient> the more your head explodes, the more space there is for Haskell (?)
2022-01-21 04:02:50 +0100 <ski> learning often involves a certain amount of unlearning
2022-01-21 04:03:17 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-21 04:03:36 +0100 <zzz> ski: that's not the problem with haskell
2022-01-21 04:04:01 +0100 <zzz> the problem with haskell is that learning something always requires learning something
2022-01-21 04:04:17 +0100 <zzz> it's lazily evaluated knowledge
2022-01-21 04:04:52 +0100 <zzz> to learn haskell you first need to learn haskell; otherwise = mempty
2022-01-21 04:04:56 +0100 <ski> yea, unfortunately many people come to expect to not have to learn that much new
2022-01-21 04:05:44 +0100 <ski> oh, yea, i see what you mean. learning is often circumambulatory, spiraling. you learn about A, then B, then C, then A again, but now from a "higher viewpoint", since you've at least to some degree covered those other terrains
2022-01-21 04:06:04 +0100 <johnjaye> zzz: i think what really gets people discouraged is yak shaving. to learn A you need B. But B depends on C. you need D to finish C. etc
2022-01-21 04:06:26 +0100 <zzz> tell me *anything* about haskell, and your sentence will invariable end with an asterisk
2022-01-21 04:06:51 +0100 <EvanR> haskell is purely functional
2022-01-21 04:06:52 +0100cyphase(~cyphase@user/cyphase)
2022-01-21 04:06:58 +0100 <ski> finding out the proper order in which to introduce concepts, when attempting to teach a topic, can be quite hard
2022-01-21 04:07:23 +0100 <ski> (also considering that people come from different backgrounds, have different learning styles and preferences, &c.)
2022-01-21 04:07:25 +0100 <EvanR> asterisk in the same sense that "the sky is blue" has asterisk
2022-01-21 04:08:11 +0100 <EvanR> well hopefully it's purely functional more often than the sky is blue
2022-01-21 04:08:36 +0100zzzunsafely performs IO
2022-01-21 04:08:57 +0100 <EvanR> gross
2022-01-21 04:09:10 +0100 <ephemient> Haskell† is‡ purely§ functional¶ (no asterisks)
2022-01-21 04:09:32 +0100 <EvanR> haha depending on what the definition of is is
2022-01-21 04:09:42 +0100 <monochrom> Haskell is Haskell.
2022-01-21 04:10:04 +0100ski. o O ( "Résumé" by Roman Cheplyaka,Maria Kovalyova in 2010-12-12 at <https://ro-che.info/ccc/11> )
2022-01-21 04:10:07 +0100 <monochrom> I guess your asterisk footnote is "yeah it's a tautology, nothing to see here"
2022-01-21 04:11:50 +0100 <monochrom> "to learn A you need B. But B depends on C. you need D to finish C. etc" holds for learning by dive-in projects only.
2022-01-21 04:12:09 +0100ski. o O ( <https://xkcd.com/703/>,<http://www.vex.net/~trebla/humour/tautologies.html> )
2022-01-21 04:12:18 +0100 <ephemient> haskell == haskell -- requires evaluating `haskell'
2022-01-21 04:12:35 +0100 <monochrom> "I want to learn Haskell, I heard that dive-in projects are best for learning programming, I conclude that I want to learn Haskell by a webapp project."
2022-01-21 04:12:51 +0100 <monochrom> This is why I recommend against dive-in projects.
2022-01-21 04:13:36 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-21 04:13:47 +0100 <monochrom> Oh it's how you learned Python? Well Python is different.
2022-01-21 04:14:06 +0100 <monochrom> Oh you cannot learn programming some other way? Well natural selection...
2022-01-21 04:14:56 +0100 <ephemient> I learned Python by reading all the docs first. I tried to do that for Haskell but I don't think I ever finished…
2022-01-21 04:14:59 +0100 <monochrom> Oh you conclude that Haskell is harder to learn? I agree.
2022-01-21 04:15:10 +0100glassy(~glassy@user/glassy) (Quit: Leaving)
2022-01-21 04:15:18 +0100 <monochrom> Whereas Python is harder to write correct code in.
2022-01-21 04:15:40 +0100 <EvanR> it's how I wrote some terrible python programs but not how I learned python (never learned it)
2022-01-21 04:16:51 +0100 <ski> "My reasoning was simple, by writing a Haskell compiler in Haskell I will double my language learning speed since I will not only have to learn how to program in it by forcing myself to complete a non-trivial project, but also its subtle semantics and dark corners since I actually needed to implement it correctly."
2022-01-21 04:17:02 +0100 <ski> "Writing a compiler is also doubly efficient to begin with, since if you self-compile improvements not only give you a better optimizer, but also speed up your self-compiled compiler. All in all I figure I was making very good use of my time. For some reason, when I explain my reasoning to other people they look at me like I am crazy, but I can detect no flaw in my logic."
2022-01-21 04:17:07 +0100 <ski> -- John Meacham,"The story of jhc",<http://www.repetae.net/computer/jhc/jhc.shtml#the-story-of-jhc>
2022-01-21 04:17:45 +0100 <monochrom> Success stories are written by the victors. >:)
2022-01-21 04:18:19 +0100 <ski> :>
2022-01-21 04:18:28 +0100 <EvanR> each time you optimize the compiler, your optimization rate increases, requiring a theory of analysis to explain how your speed didn't diverge
2022-01-21 04:18:48 +0100 <zzz> ephemient: i don't think we've finished writing them
2022-01-21 04:19:59 +0100 <ephemient> the rest of them are probably just behind that thunk over there
2022-01-21 04:20:15 +0100 <zzz> pkill -9 ghc
2022-01-21 04:22:10 +0100 <hughjfchen> Anyone knows the path library? I use parseSomeFile to parse a filepath into a path, then use filename try to get the filename from the path. However, I got an error message saying that cannot match 'SomeBase File' with 'File'.
2022-01-21 04:22:17 +0100kaph(~kaph@net-2-47-208-144.cust.vodafonedsl.it) (Ping timeout: 240 seconds)
2022-01-21 04:22:55 +0100 <zzz> jhc looks interesting
2022-01-21 04:23:01 +0100alp(~alp@user/alp) (Ping timeout: 268 seconds)
2022-01-21 04:23:21 +0100 <hughjfchen> I already pattern match the return of parseSomeFile
2022-01-21 04:23:27 +0100 <zzz> where can i learn more about system E?
2022-01-21 04:24:26 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 250 seconds)
2022-01-21 04:26:01 +0100 <hughjfchen> code is here: https://i.imgur.com/iDjEbCK.png
2022-01-21 04:27:31 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2022-01-21 04:27:31 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2022-01-21 04:27:31 +0100finn_elijaFinnElija
2022-01-21 04:32:06 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-21 04:32:40 +0100td_(~td@muedsl-82-207-238-049.citykom.de) (Ping timeout: 250 seconds)
2022-01-21 04:33:36 +0100 <ephemient> prjSomeBase filename <$> parseSomeFile f
2022-01-21 04:34:40 +0100td_(~td@94.134.91.211)
2022-01-21 04:35:05 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2022-01-21 04:35:28 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2022-01-21 04:37:48 +0100 <hughjfchen> ephemient: thanks, ephemient, I'll have a try
2022-01-21 04:40:28 +0100nineonine(~nineonine@2604:3d08:7780:cd00:e983:291a:d390:4809)
2022-01-21 04:40:47 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 04:42:09 +0100 <hughjfchen> ephemient: thanks, it works.
2022-01-21 04:42:55 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:509a::1) (Quit: The Lounge - https://thelounge.chat)
2022-01-21 04:43:36 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 04:44:08 +0100terrorjack(~terrorjac@2a01:4f8:1c1e:509a::1)
2022-01-21 04:49:48 +0100vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2022-01-21 04:50:43 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 04:50:57 +0100vglfr(~vglfr@88.155.104.216) (Ping timeout: 240 seconds)
2022-01-21 04:52:11 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2022-01-21 04:53:12 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2022-01-21 04:55:24 +0100wombat875(~wombat875@pool-72-89-24-154.nycmny.fios.verizon.net) (Quit: WeeChat 2.2-dev)
2022-01-21 04:55:37 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 240 seconds)
2022-01-21 04:59:11 +0100[_][itchyjunk]
2022-01-21 05:00:01 +0100haasn(~nand@haasn.dev) (Quit: ZNC 1.7.5+deb4 - https://znc.in)
2022-01-21 05:00:05 +0100lechner(~lechner@debian/lechner)
2022-01-21 05:01:21 +0100haasn(~nand@haasn.dev)
2022-01-21 05:02:44 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2022-01-21 05:04:57 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4) (Ping timeout: 268 seconds)
2022-01-21 05:06:47 +0100vglfr(~vglfr@88.155.98.86)
2022-01-21 05:13:37 +0100Guest24(~Guest24@144-124-136-14.pip.aber.ac.uk) (Quit: Client closed)
2022-01-21 05:15:32 +0100 <zzz> first error day! i had never seen this one before:
2022-01-21 05:15:36 +0100 <zzz> Wildcard ‘_’ not allowed in a constraint
2022-01-21 05:15:36 +0100 <zzz> except as the last top-level constraint of a type signature
2022-01-21 05:15:36 +0100 <zzz> e.g f :: (Eq a, _) => blah
2022-01-21 05:15:36 +0100 <zzz> in the type signature for ‘y’
2022-01-21 05:15:36 +0100 <zzz> |
2022-01-21 05:15:39 +0100 <zzz> 15 | y :: (_,_) => (a,_)
2022-01-21 05:15:41 +0100 <zzz> | ^
2022-01-21 05:16:08 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net)
2022-01-21 05:16:37 +0100zmt01(~zmt00@user/zmt00) (Ping timeout: 240 seconds)
2022-01-21 05:17:17 +0100geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca) (Ping timeout: 240 seconds)
2022-01-21 05:17:40 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 05:18:05 +0100zmt00(~zmt00@user/zmt00)
2022-01-21 05:21:25 +0100faustind(~faustin@M014008067225.v4.enabler.ne.jp)
2022-01-21 05:25:51 +0100lbseale(~ep1ctetus@user/ep1ctetus) (Read error: Connection reset by peer)
2022-01-21 05:29:00 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 250 seconds)
2022-01-21 05:29:02 +0100shriekingnoise(~shrieking@201.231.16.156) (Quit: Quit)
2022-01-21 05:29:27 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 05:29:52 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Ping timeout: 250 seconds)
2022-01-21 05:30:45 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2022-01-21 05:31:00 +0100shriekingnoise(~shrieking@201.231.16.156)
2022-01-21 05:31:27 +0100incertia(~incertia@207.98.176.40)
2022-01-21 05:31:28 +0100 <Axman6> just leave it out and the compiler will tell you what constraint isn't matched
2022-01-21 05:40:48 +0100 <zzz> i know i was just playing around
2022-01-21 05:42:34 +0100mbuf(~Shakthi@110.225.224.187)
2022-01-21 05:44:58 +0100zmt00(~zmt00@user/zmt00) (Read error: Connection reset by peer)
2022-01-21 05:46:21 +0100zmt00(~zmt00@user/zmt00)
2022-01-21 05:51:47 +0100 <Axman6> Guest96: you should do this if you're are writing Haskell in Notepad++ https://community.notepad-plus-plus.org/topic/18041/tab-key-enters-spaces-instead-of-tab
2022-01-21 05:52:36 +0100 <zzz> anyone using hls in vim?
2022-01-21 05:52:38 +0100 <Axman6> uh, meant Guest24, who's now gone
2022-01-21 05:52:59 +0100 <Guest96> lmao, I was so confused
2022-01-21 05:54:23 +0100 <ephemient> zzz: there's also no reason for (_, _) => as (_) => can stand in for multiple constraints
2022-01-21 05:54:33 +0100 <CHUD> I have a module where we are learning haskell
2022-01-21 05:54:39 +0100 <CHUD> can I hang out here?
2022-01-21 05:58:05 +0100 <sm> sure
2022-01-21 06:00:44 +0100 <Axman6> CHUD: you can even ask questions, but if they're homework, remember to tell us - we won't give you answers to the questions but will guide you so you learn the answers yourself
2022-01-21 06:03:32 +0100 <CHUD> Yeah, we just started this week so we haven't been set anything, I'm mainly looking for learning recommendations atm
2022-01-21 06:04:21 +0100 <ski> you've been suggested any textbook ?
2022-01-21 06:04:41 +0100 <CHUD> learnyouahaskell.com/
2022-01-21 06:04:46 +0100skinods
2022-01-21 06:05:27 +0100 <jackdk> welcome aboard CHUD
2022-01-21 06:05:48 +0100 <ski> both beginner and more advanced questions are allowed in here. and both more practical and more theoretical. something the channel is more silent, sometimes more busy. sometimes multiple conversations are going on at the same time
2022-01-21 06:07:32 +0100 <ski> you're welcome to lurk around, and see what people talk about. perhaps you could learn some stuff from seeing some questions/problems that other people have (iow, if you feel like it, you don't have to join only when you want a question answered, and then leave directly after you've got an answer. it can pay off to stick around a bit more)
2022-01-21 06:09:03 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 256 seconds)
2022-01-21 06:09:06 +0100 <ski> LYAH has pretty pics. one problem though is that it doesn't have exercises
2022-01-21 06:09:51 +0100 <ski> (also, some people think that LYAH can be a bit confusing, that some other learning resources can be better)
2022-01-21 06:09:58 +0100zebrag(~chris@user/zebrag) (Quit: Konversation terminated!)
2022-01-21 06:09:59 +0100 <ski> anyway, if you want to, you could also check out
2022-01-21 06:10:01 +0100 <ski> @where CIS194
2022-01-21 06:10:01 +0100 <lambdabot> https://www.seas.upenn.edu/~cis194/spring13/lectures.html
2022-01-21 06:10:02 +0100 <CHUD> Yeah I am looking for something like mooc.fi java but for haskell
2022-01-21 06:10:09 +0100 <ski> which has exercises
2022-01-21 06:10:41 +0100 <oak-> Doesn't mooc.fi have Haskell? :P
2022-01-21 06:10:53 +0100chomwitt(~chomwitt@athedsl-15695.home.otenet.gr)
2022-01-21 06:10:58 +0100nunggu(~q@user/nunggu)
2022-01-21 06:11:14 +0100 <oak-> https://haskell.mooc.fi/
2022-01-21 06:11:14 +0100 <CHUD> I don't think so, I only found python and some cyber sec. stuff
2022-01-21 06:11:20 +0100 <CHUD> nvm
2022-01-21 06:11:30 +0100 <oak-> (I'm in Haskell Mooc's Telegram group)
2022-01-21 06:12:10 +0100ksqsf(~user@210.45.76.145)
2022-01-21 06:12:33 +0100ksqsf(~user@210.45.76.145) (Client Quit)
2022-01-21 06:12:51 +0100 <CHUD> cool, thanks for that
2022-01-21 06:12:57 +0100ksqsf(~user@2001:da8:d800:336:ecbe:7994:fa3f:f03c)
2022-01-21 06:13:01 +0100 <CHUD> have you completed the course?
2022-01-21 06:13:31 +0100 <oak-> No, the part one was a little too beginner course for me, I could check part two though
2022-01-21 06:14:00 +0100 <nunggu> what course? i want to learn haskell but i'm too lazy to read docs...
2022-01-21 06:14:20 +0100 <nunggu> oh, this one: https://haskell.mooc.fi/, right?
2022-01-21 06:14:25 +0100 <oak-> Yes
2022-01-21 06:16:08 +0100 <oak-> I have learned Haskell "the hard way" over the years, but I have read haskellbook.com and I have Real World Haskell as a physical copy. I'm currently reading Thinking with Types to learn more about type-level programming
2022-01-21 06:16:50 +0100 <CHUD> I don't want to end up in tutorial hell that's my main objective
2022-01-21 06:17:01 +0100 <nunggu> i copied (from the web), pasted, edited xmonad.hs til it compiled. all without knowing how it supposed to work
2022-01-21 06:17:43 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 268 seconds)
2022-01-21 06:20:05 +0100 <oak-> What I still don't completely grasp is how to practically use Monad Transformer Stacks to structure a program. I've been using ReaderT Design Pattern combined with RIO to create software to run in production, also effect systems using free monads (such as polysemy) look interesting
2022-01-21 06:20:37 +0100 <jackdk> oak-: https://github.com/qfpl/applied-fp-course/blob/master/bonus/mtl.md may help
2022-01-21 06:21:24 +0100 <oak-> Thanks, I'll have to bookmark this for later
2022-01-21 06:21:42 +0100 <zzz> i don't like monad transformers
2022-01-21 06:22:41 +0100 <zzz> and feel the urge to announce it whenever someone mentions it
2022-01-21 06:22:46 +0100 <zzz> carry on
2022-01-21 06:22:50 +0100 <oak-> It could be still useful to understand them, to be able to read code written by others, which uses Monad Transformers
2022-01-21 06:22:54 +0100 <Axman6> do you have much experience using them?
2022-01-21 06:23:42 +0100 <zzz> no i don't
2022-01-21 06:23:54 +0100 <CHUD> I'm curious, as I ended up hear my accident after reading the IRC wiki page, how long you guys been on here for? do you prefer it over other channels or community platforms and why?
2022-01-21 06:23:54 +0100 <zzz> not at all
2022-01-21 06:23:59 +0100 <CHUD> here*
2022-01-21 06:24:31 +0100 <Axman6> being able to use MTL and have code which says things like foo (HasDatabase m, HasConfig m, HasLogging m) => m () is pretty useful, it makes it clear what effects something can use, and what it can't
2022-01-21 06:25:23 +0100 <Axman6> I've been here for like 13 years, IRC has always been the best medium for ad hoc help IMO. StackOverflow has no easy ability to have a conversation, and modern chat platforms are pretty awful with thousands of users
2022-01-21 06:25:36 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2022-01-21 06:25:40 +0100 <jackdk> I like that it's an open protocol, and I can connect with whatever client that pleases me. Modern chat platforms are too often proprietary silos.
2022-01-21 06:25:51 +0100nunggu(~q@user/nunggu) (Ping timeout: 276 seconds)
2022-01-21 06:25:55 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2022-01-21 06:25:59 +0100 <oak-> And it is useful for mocks in testing as well (to have those Has-typeclasses)
2022-01-21 06:26:26 +0100 <Axman6> yeah, your code is decoupled from the implementation of those effects
2022-01-21 06:27:01 +0100 <Axman6> zzz: that's kinda like saying "I don't like rug making, no I have never even tried to make a rug". why would you hate something you don't understand?
2022-01-21 06:28:50 +0100nunggu(~q@user/nunggu)
2022-01-21 06:30:00 +0100 <oak-> I'd say you actually start to learn monads when you get your hands dirty with them, and try to do stuff with monads
2022-01-21 06:30:58 +0100nshepperd2(~nshepperd@li364-218.members.linode.com) (Quit: Ping timeout (120 seconds))
2022-01-21 06:31:09 +0100nshepperd2(~nshepperd@li364-218.members.linode.com)
2022-01-21 06:31:44 +0100 <ski> CHUD : some twenty years
2022-01-21 06:31:45 +0100 <Axman6> It turns out that a lot of what you really need for real applications is ReaderT, which contains any config you need, connection objects, logging functions etc. but it can be nice to be able to talk about those separately
2022-01-21 06:32:19 +0100 <zzz> Axman6: your question was "do you have much experience using them?"
2022-01-21 06:32:47 +0100 <zzz> not "do you understand them?" or "have you ever used them?"
2022-01-21 06:32:54 +0100 <zzz> but i get your point
2022-01-21 06:33:30 +0100 <Axman6> I'm just curious why you even have the opinion that you don't like them
2022-01-21 06:34:11 +0100 <zzz> oh, that's personal taste. i don't advise against it
2022-01-21 06:34:31 +0100 <Axman6> what alternative do you perfer?
2022-01-21 06:34:57 +0100 <zzz> depends on the problem i'm trying to solve
2022-01-21 06:36:09 +0100 <zzz> i can't think of a case where you *need* monad transformers
2022-01-21 06:36:10 +0100 <CHUD> when using something like discord, people add too many channels and the conversation get's fragmented, it also stop people from posting because they think it's not active
2022-01-21 06:37:16 +0100 <ski> (and yea, i like the spontaneity, but also the occasional conversation over larger spans of time. and the non-proprietaryness, openness to different clients, lack of built-in / blessed logging, lack of (in-line) images and other such nonsense, and (mostly) lack of emoji. (i believe that many of these contribute to particularities of IRC culture in a way that might not be completely evident). obviously we
2022-01-21 06:37:17 +0100 <Axman6> people get confused by IRC by joining and not seeing anyone talk for five minutes - if you have a question, you just ask it, and if people are around they'll answer
2022-01-21 06:37:22 +0100 <ski> have our share of problems and drama as well, though)
2022-01-21 06:37:55 +0100 <Axman6> 💩
2022-01-21 06:37:57 +0100joeyh_(~joeyh@kitenet.net) (Ping timeout: 256 seconds)
2022-01-21 06:37:59 +0100 <zzz> ski: what's "blessed" logging?
2022-01-21 06:38:20 +0100joeyh(joeyh@kitenet.net)
2022-01-21 06:38:25 +0100 <ksqsf> I was fond of monad transformers until I learned about MonadBaseControl
2022-01-21 06:38:39 +0100 <ski> like in Discord, it's built-in to the client. you can see backlog from before you joined. i think that's probably a bad idea
2022-01-21 06:38:46 +0100 <Axman6> MonadBaseControl is pretty horrible IMO
2022-01-21 06:39:17 +0100 <Axman6> Yeah, we talk crap about ski all the time when they're not here
2022-01-21 06:39:35 +0100 <ski> (makes people be more cautious with what they say, since someone else, who wasn't present, can later search through history and pick up some statement)
2022-01-21 06:39:38 +0100skigrins
2022-01-21 06:39:39 +0100lechner(~lechner@debian/lechner) (Ping timeout: 256 seconds)
2022-01-21 06:39:49 +0100 <Axman6> oh no
2022-01-21 06:40:10 +0100 <ski> (oh, also, i'm against "karma" and "like & dislike" systems ..)
2022-01-21 06:40:17 +0100zmt00(~zmt00@user/zmt00) (Ping timeout: 240 seconds)
2022-01-21 06:40:20 +0100ksqsfhesitates to point out this channel has public logging
2022-01-21 06:40:23 +0100 <zzz> ski +1
2022-01-21 06:40:27 +0100skitwitches
2022-01-21 06:40:42 +0100 <Axman6> oh no, my life is ruined
2022-01-21 06:41:06 +0100 <ski> ksqsf : yea, i'm full aware. but it's not an automatic default on all channels. and it's recommended on Libera to mention such a thing in channel topic on on-join notice
2022-01-21 06:41:09 +0100 <ephemient> zzz, well you don't "need" monads either. monad transformers are a tool with a certain set of trade-offs
2022-01-21 06:41:29 +0100 <zzz> ephemient: great point
2022-01-21 06:41:36 +0100skihugs Axman6
2022-01-21 06:42:11 +0100 <zzz> the only annoying thing about irc is this actions nonsense
2022-01-21 06:42:19 +0100 <ski> hehe
2022-01-21 06:42:35 +0100 <jackdk> ski: good point about the lack of emoji and karma systems. I approve `:)`
2022-01-21 06:42:37 +0100 <Axman6> Thanks dude
2022-01-21 06:42:43 +0100 <jackdk> (emoticons are fine, IMHO)
2022-01-21 06:42:45 +0100 <ski> :)
2022-01-21 06:42:57 +0100 <ski> (yea, smileys are okay)
2022-01-21 06:43:00 +0100 <Axman6> :thinkingface:
2022-01-21 06:43:04 +0100 <ksqsf> (^_^)
2022-01-21 06:43:19 +0100 <Axman6> (ಠ_ಠ)
2022-01-21 06:43:22 +0100 <CHUD> https://becca.ooo/discord
2022-01-21 06:43:23 +0100skiglances around nervously
2022-01-21 06:43:55 +0100 <zzz> well, even emoticons are up to the client
2022-01-21 06:44:04 +0100rusrushal13(~rusrushal@2401:4900:5d31:3217:d016:3e1b:c176:62e9)
2022-01-21 06:44:07 +0100 <zzz> irc is encding agnostic
2022-01-21 06:44:09 +0100 <qrpnxz> ksqsf, what do you think of https://hackage.haskell.org/package/layers
2022-01-21 06:44:30 +0100 <qrpnxz> (asking because you mentioned MonadBaseControl)
2022-01-21 06:44:47 +0100 <glguy> agnostish, it support encodings that agree on what \0, \r, and \n mean
2022-01-21 06:44:53 +0100 <ksqsf> qrpnxz: never used that
2022-01-21 06:45:14 +0100 <oak-> I don't want to run IRC-client in a shell anymore, but luckily it is also possible to connect through Matrix bridge
2022-01-21 06:45:19 +0100joeyh(joeyh@kitenet.net) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2022-01-21 06:45:31 +0100 <ksqsf> I still use mtl primarily, but a proper effect system will solve pretty much all the pain points
2022-01-21 06:45:33 +0100 <Axman6> every encoding should agree that \0 is a perfectly good character
2022-01-21 06:45:42 +0100shriekingnoise(~shrieking@201.231.16.156) (Quit: Quit)
2022-01-21 06:45:59 +0100 <ski> there's also GUI clients
2022-01-21 06:45:59 +0100joeyh(~joeyh@kitenet.net)
2022-01-21 06:46:33 +0100 <glguy> or even better web clients
2022-01-21 06:46:43 +0100 <zzz> oak-: the libera-wide matrix bridge sucks
2022-01-21 06:46:55 +0100ski. o O ( "Team Chat" <https://xkcd.com/1782/> )
2022-01-21 06:47:04 +0100slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2022-01-21 06:47:19 +0100 <sm> I find it mostly works fine zzz
2022-01-21 06:47:25 +0100 <Axman6> glguy make the best client though
2022-01-21 06:47:28 +0100 <oak-> zzz: Why?
2022-01-21 06:47:31 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2022-01-21 06:47:48 +0100glguyhigh-fives Axman6
2022-01-21 06:47:57 +0100 <qrpnxz> i use an xmpp bridge
2022-01-21 06:48:01 +0100 <Axman6> it is frustrating when someone joins using matrix and doesn't realise it's actuall IRC, and then constantly edits their messages
2022-01-21 06:48:08 +0100 <CHUD> goodnight all
2022-01-21 06:48:09 +0100 <qrpnxz> lol
2022-01-21 06:48:22 +0100 <ski> g'night, CHUD, have fun with your Haskell learning !
2022-01-21 06:48:29 +0100 <monochrom> Such revisionists.
2022-01-21 06:48:29 +0100nshepperd(nshepperd@2600:3c03::f03c:92ff:fe28:92c9) (Ping timeout: 252 seconds)
2022-01-21 06:48:34 +0100 <Axman6> I feel like I've never had a "why IRC" conversation on IRC before...
2022-01-21 06:48:48 +0100 <CHUD> inception vibes
2022-01-21 06:48:53 +0100 <ski> happens occasionally
2022-01-21 06:48:56 +0100 <zzz> glguy: trying out your client is in my todo list
2022-01-21 06:48:57 +0100 <Axman6> "WHy are we here?"
2022-01-21 06:49:11 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net) (Remote host closed the connection)
2022-01-21 06:49:17 +0100 <glguy> Axman6: because we'd have to disconnect to not be here.
2022-01-21 06:49:22 +0100 <Axman6> glirc really is excellent, I moved from irssi and haven't looked back. I'd been using irssi for over a decade then
2022-01-21 06:49:38 +0100 <ksqsf> IRC is great, I don't have to spend time on picking the best profile icon
2022-01-21 06:49:41 +0100 <zzz> i'm using irssi
2022-01-21 06:50:24 +0100 <monochrom> I made the best profile icon ever. You can see it on my github profile, https://github.com/treblacy/
2022-01-21 06:50:25 +0100 <zzz> i've invested so much in configuring it. "i have it just the way i like it"
2022-01-21 06:50:28 +0100nshepperd(nshepperd@2600:3c03::f03c:92ff:fe28:92c9)
2022-01-21 06:50:46 +0100 <Axman6> there's a couple of feature I miss but they're not a big deal... the only one that comes to mind is better support for split screens (I don't understand how glirc's work) - I used to always have a 20 line high split with just mentions in it
2022-01-21 06:50:54 +0100 <ski> (re absence of logging, it seems to me this contributes to (many, though not all) people (regulars) staying connected for longer period of times, and thus contributes to the common "lurk until someone says something interesting" pattern. also picking up threads and conversations from a while ago)
2022-01-21 06:51:18 +0100 <glguy> Axman6: glirc's split screen works like how I used xmonad
2022-01-21 06:51:23 +0100 <Axman6> ski: I like the lack of time pressure that brings
2022-01-21 06:51:26 +0100 <ksqsf> monochrom: nice gradient!
2022-01-21 06:51:28 +0100 <ski> yes
2022-01-21 06:51:36 +0100 <glguy> a column for a main window, and a column for the stuff I'm watching
2022-01-21 06:51:59 +0100 <glguy> (or optionally all in one column)
2022-01-21 06:52:27 +0100 <glguy> zzz: It's best for me, but not for everyone. You'll likely find you prefer irssi :)
2022-01-21 06:52:28 +0100 <Axman6> would love to know how to do that - I think I tried but couldn't figure out how to a) have a fixed size window with mentions/highlights, b) how to configure that in the config
2022-01-21 06:53:24 +0100 <ski> zzz : well, using Irssi, i've still only made very few customizations (i guess i've very lazy/tolerant/reluctant to cross the threshold to adding much such stuff)
2022-01-21 06:53:50 +0100 <Axman6> I definitely found glirc easier to configure than irssi
2022-01-21 06:54:34 +0100 <Axman6> Also, by default there's a highlight set up for the word glirc, so I know that every time I say glirc it highlights all the glirc users
2022-01-21 06:54:43 +0100 <zzz> oak-: it's a long list, but between dropped messages, not rare over a minute latency (up to 2 hours, i've experienced) and weird stuff like messages not being sent when not all matrix users in one channel can see eachother or something like that
2022-01-21 06:54:45 +0100 <Axman6> and that gived me warm, fuzzy feelings
2022-01-21 06:54:48 +0100 <Axman6> gives*
2022-01-21 06:55:16 +0100glguy_(x@libera/staff/glguy)
2022-01-21 06:55:19 +0100 <ski> hehe :)
2022-01-21 06:56:00 +0100glguy_(x@libera/staff/glguy) (Remote host closed the connection)
2022-01-21 06:56:13 +0100 <zzz> glguy: i don't know. the video really convinced me
2022-01-21 06:56:35 +0100 <zzz> i think you have a demo somewhere
2022-01-21 06:56:45 +0100 <oak-> I used glirc as a library when I experimented creating an IRC bot with Haskell :-P
2022-01-21 06:56:55 +0100Guest96(~Guest96@144-124-99-115.pip.aber.ac.uk) (Quit: Client closed)
2022-01-21 06:57:33 +0100 <jackdk> monochrom: On some sites I have a 1x1 transparent PNG as my avatar
2022-01-21 06:57:45 +0100 <jackdk> I approve of this gradient though, very tasteful
2022-01-21 06:57:48 +0100 <oak-> but generally I would recommend Weechat over Irssi based on my experience
2022-01-21 06:58:08 +0100 <ephemient> the "must stay connected to lurk" "feature" of IRC is more of a hindrance than a benefit IMO. IRC is only usable to me by working around that with a bouncer
2022-01-21 06:58:10 +0100johnw(~johnw@2607:f6f0:3004:1:c8b4:50ff:fef8:6bf0) (Quit: ZNC - http://znc.in)
2022-01-21 06:58:16 +0100 <glguy> super brief recording just now: https://asciinema.org/a/u2AJqyXz3z2cYAlBui84Danid - old video https://www.youtube.com/watch?v=taz0-hZwWP4
2022-01-21 06:59:07 +0100 <ski> fwiwi, "Why I no longer contribute to StackOverflow" by ttmrichter in 2013-12 at <https://web.archive.org/web/20140104210553/http://michael.richter.name/blogs/why-i-no-longer-contr…> talks a bit about artificial scoring systems ("gamification")
2022-01-21 06:59:10 +0100 <glguy> I should make a new demo video at some point
2022-01-21 07:00:14 +0100 <Axman6> showing splitting would be good :P
2022-01-21 07:00:39 +0100 <zzz> love asciinema
2022-01-21 07:00:59 +0100 <ski> ephemient : yes, but that means that it's people who care enough that have access to fuller logs, rather than just any random denizen of the internet
2022-01-21 07:01:08 +0100glguy_(x@libera/staff/glguy)
2022-01-21 07:01:25 +0100 <ephemient> s/care enough/have access to full-time computing power
2022-01-21 07:01:43 +0100 <ski> (but i agree there's both pros and cons. i suspect the pros of the lack overweight the cons)
2022-01-21 07:01:50 +0100 <ski> yea
2022-01-21 07:02:12 +0100 <Axman6> I just run glirc in tmux :\
2022-01-21 07:03:10 +0100glguy_(x@libera/staff/glguy) (Remote host closed the connection)
2022-01-21 07:04:10 +0100 <glguy> aw shoot. I made a perfectly good recording with splits; but I resized the terminal during it and that's not supported
2022-01-21 07:04:16 +0100 <ski> (i suspect that one reason for the perceived wealth of rudeness and hostility on systems like Twitter is due to its relative lack of localization into communities)
2022-01-21 07:04:35 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 07:04:38 +0100 <ski> (obviously there's also many other contributing factors)
2022-01-21 07:05:01 +0100 <zzz> glguy: you should clarify that's not supported *by asciinema*
2022-01-21 07:05:23 +0100 <zzz> ;)
2022-01-21 07:05:47 +0100 <ephemient> yeah. I think it's impossible to build a global community without shared mores, but at the same time global communication is incredibly useful…
2022-01-21 07:05:59 +0100skinods
2022-01-21 07:06:47 +0100 <zzz> this will eventually turn into a ruseeau vs hobbes discussin
2022-01-21 07:07:14 +0100ph88(~ph88@tmo-085-109.customers.d1-online.com) (Remote host closed the connection)
2022-01-21 07:07:31 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50)
2022-01-21 07:07:37 +0100shapr(~user@2601:7c0:c37c:46d0:2da1:8e76:2324:a881) (Ping timeout: 240 seconds)
2022-01-21 07:07:43 +0100 <zzz> *rousseau *discussion
2022-01-21 07:07:48 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-21 07:08:07 +0100 <ski> would you like to elaborate ? :)
2022-01-21 07:08:12 +0100 <Axman6> I have no idea where most of you are, and it doesn't really matter
2022-01-21 07:08:50 +0100 <ski> (yea, localization doesn't have to be geographic)
2022-01-21 07:09:03 +0100 <monochrom> Hobbes argues that people should be ruled by tigers. Calvin argues that people should be ruled by kids.
2022-01-21 07:09:51 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-21 07:10:20 +0100 <Axman6> Both are correct
2022-01-21 07:10:34 +0100 <ski> tiger kittehs, then ?
2022-01-21 07:11:49 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-21 07:11:59 +0100ski. o O ( "fixed in teh HEAD" <https://lambdacats.github.io/fixed-in-head/> )
2022-01-21 07:12:10 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2022-01-21 07:12:18 +0100 <zzz> are people inherently bad and regulated by society, or the opposite? this is the usual simplified dicothomy. Hobbes however (usualy presented as the preponent of the "people are bad" theory) has a nuanced argument involving scale and such
2022-01-21 07:12:38 +0100 <zzz> iirc
2022-01-21 07:12:47 +0100 <zzz> long time since i read them
2022-01-21 07:13:29 +0100 <zzz> proponent? english is not my native language
2022-01-21 07:13:50 +0100 <ski> aye
2022-01-21 07:13:55 +0100 <ski> @wn proponent
2022-01-21 07:13:56 +0100 <lambdabot> *** "proponent" wn "WordNet (r) 3.0 (2006)"
2022-01-21 07:13:56 +0100 <lambdabot> proponent
2022-01-21 07:13:56 +0100 <lambdabot> n 1: a person who pleads for a cause or propounds an idea [syn:
2022-01-21 07:13:56 +0100 <lambdabot> {advocate}, {advocator}, {proponent}, {exponent}]
2022-01-21 07:14:14 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 07:18:08 +0100 <zzz> one thing i miss here is the ability to follow conversations easily
2022-01-21 07:19:14 +0100 <EvanR> lambdabot is like the starship enterprise or the tardis, what it can do is never fully fleshed out but if it would be appropriat suddenly it's possible
2022-01-21 07:19:20 +0100 <zzz> like sometimes i wish we would tag our messages with hashes corresponfing to the not-really-a-thread(s) we're replying to
2022-01-21 07:20:14 +0100mud(~mud@user/kadoban) (Quit: quit)
2022-01-21 07:20:42 +0100 <zzz> -eb0c76- if you know what i mean
2022-01-21 07:21:14 +0100 <EvanR> chat... *it's not linear*
2022-01-21 07:21:39 +0100 <ski> it becomes a bit easier, with some practice
2022-01-21 07:22:09 +0100 <zzz> ski: what does?
2022-01-21 07:22:16 +0100 <zzz> oh, right
2022-01-21 07:22:29 +0100 <zzz> you forgot the -eb0c76-
2022-01-21 07:22:41 +0100 <zzz> i'm making it a thing
2022-01-21 07:22:49 +0100 <ski> > 0xeb0c76
2022-01-21 07:22:51 +0100 <lambdabot> 15404150
2022-01-21 07:23:14 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50) (Remote host closed the connection)
2022-01-21 07:23:24 +0100 <zzz> no easter egg, just a random hash :p
2022-01-21 07:23:32 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50)
2022-01-21 07:23:33 +0100 <EvanR> > sort (show 15404150)
2022-01-21 07:23:34 +0100 <lambdabot> "00114455"
2022-01-21 07:23:38 +0100 <EvanR> > num it
2022-01-21 07:23:39 +0100 <lambdabot> error:
2022-01-21 07:23:39 +0100 <lambdabot> • Variable not in scope: num :: t0 -> t
2022-01-21 07:23:39 +0100 <lambdabot> • Perhaps you meant one of these:
2022-01-21 07:23:45 +0100 <EvanR> > nub it
2022-01-21 07:23:47 +0100 <lambdabot> error:
2022-01-21 07:23:47 +0100 <lambdabot> • Variable not in scope: it :: [a]
2022-01-21 07:23:47 +0100 <lambdabot> • Perhaps you meant one of these:
2022-01-21 07:23:49 +0100 <ski> doesn't look that random, to me .. :D
2022-01-21 07:24:15 +0100cyphase(~cyphase@user/cyphase)
2022-01-21 07:24:27 +0100 <zzz> > nub $ show 0xeb0c76
2022-01-21 07:24:28 +0100 <lambdabot> "1540"
2022-01-21 07:24:35 +0100 <ski> % :t it
2022-01-21 07:24:36 +0100 <yahb> ski: TypeRep
2022-01-21 07:26:02 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 07:26:02 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 07:26:02 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 07:26:18 +0100michalz(~michalz@185.246.204.43)
2022-01-21 07:26:21 +0100 <EvanR> any time you enter a derelict haskell spaceship, first thing you check is the type and possibly value of `it'
2022-01-21 07:27:06 +0100 <ski> be careful not to bump any bottom
2022-01-21 07:27:43 +0100 <zzz> never evaluate foreign values
2022-01-21 07:28:14 +0100 <ski> unless they're Trustworthy
2022-01-21 07:28:48 +0100 <zzz> yeah right
2022-01-21 07:28:53 +0100 <EvanR> in let x = x in x, no one can hear you scream
2022-01-21 07:29:19 +0100 <EvanR> ok maybe that'd be a better setting for an event horizon reference
2022-01-21 07:29:31 +0100 <zzz> which reminds me this is the right place to ask:
2022-01-21 07:29:52 +0100 <zzz> :t let a = a in a
2022-01-21 07:29:52 +0100 <lambdabot> t
2022-01-21 07:30:00 +0100 <zzz> why is it t?
2022-01-21 07:30:13 +0100 <EvanR> :t undefined
2022-01-21 07:30:14 +0100 <lambdabot> a
2022-01-21 07:30:17 +0100 <EvanR> haha...
2022-01-21 07:30:24 +0100 <ephemient> could by any type variable
2022-01-21 07:30:40 +0100 <zzz> ephemient: as can a
2022-01-21 07:30:48 +0100 <zzz> undefined
2022-01-21 07:30:58 +0100 <ephemient> @src undefined
2022-01-21 07:30:58 +0100 <lambdabot> undefined = error "Prelude.undefined"
2022-01-21 07:31:08 +0100 <ephemient> :t error
2022-01-21 07:31:09 +0100 <lambdabot> [Char] -> a
2022-01-21 07:31:13 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 07:31:15 +0100 <ephemient> thus, a
2022-01-21 07:31:23 +0100 <zzz> ok
2022-01-21 07:31:36 +0100 <EvanR> :t fix id
2022-01-21 07:31:37 +0100 <lambdabot> a
2022-01-21 07:31:47 +0100rusrushal13(~rusrushal@2401:4900:5d31:3217:d016:3e1b:c176:62e9) (Ping timeout: 256 seconds)
2022-01-21 07:31:50 +0100 <zzz> EvanR: nice
2022-01-21 07:32:04 +0100 <ephemient> :t fix error
2022-01-21 07:32:05 +0100 <lambdabot> [Char]
2022-01-21 07:32:11 +0100 <zzz> :/
2022-01-21 07:32:13 +0100 <ephemient> 🤔
2022-01-21 07:32:33 +0100 <ski> @type let f (x:xs) ys = f xs (x:ys) in f
2022-01-21 07:32:33 +0100 <lambdabot> [a] -> [a] -> t
2022-01-21 07:33:16 +0100 <ski> result type is a singleton type variable, implies you've an infinite loop (or other bottom, like `error (...)')
2022-01-21 07:33:44 +0100 <zzz> ski +1
2022-01-21 07:34:06 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2022-01-21 07:34:43 +0100 <ski> (i guess a (bottom-up) merge sort, missing its base case, might be a better example)
2022-01-21 07:35:14 +0100 <ski> > fix error
2022-01-21 07:35:15 +0100 <lambdabot> "*Exception: *Exception: *Exception: *Exception: *Exception: *Exception: *Ex...
2022-01-21 07:35:18 +0100 <ski> > fix show
2022-01-21 07:35:19 +0100 <lambdabot> "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\...
2022-01-21 07:36:03 +0100 <monochrom> Yeah, https://perl.plover.com/classes/OOPSLA/samples/slide068.html
2022-01-21 07:37:06 +0100incertia(~incertia@207.98.176.40) (Quit: ZNC 1.7.5 - https://znc.in)
2022-01-21 07:37:10 +0100 <ephemient> [] is a list of strings, so the second statement seems wrong </missing-the-point>
2022-01-21 07:37:26 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 07:38:43 +0100echoreply(~echoreply@45.32.163.16) (Quit: WeeChat 2.8)
2022-01-21 07:39:14 +0100echoreply(~echoreply@2001:19f0:9002:1f3b:5400:ff:fe6f:8b8d)
2022-01-21 07:39:19 +0100 <EvanR> 4 slides later you are confronted with a giant image of a cockaroach
2022-01-21 07:39:39 +0100 <EvanR> I command W so fast I never really understood the context of that page
2022-01-21 07:40:01 +0100 <zzz> Programming in Haskell is pleasant
2022-01-21 07:40:01 +0100 <zzz> No type declarations—everything is automatic
2022-01-21 07:40:01 +0100 <zzz> You get quite a few type errors (darn!)
2022-01-21 07:40:01 +0100 <zzz> But every error indicates a real, serious problem
2022-01-21 07:40:04 +0100 <zzz> Not like lint or C or Pascal.
2022-01-21 07:40:14 +0100 <zzz> ^ monochrom: lol
2022-01-21 07:40:24 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 07:40:46 +0100 <EvanR> not sure about you guys but I'm so bad ass I disable all the warnings and errors in haskell, I know what I'm doing
2022-01-21 07:41:18 +0100 <monochrom> Sometimes a type error indicates a typo, like int vs Int. Not sure if it's a real serious problem.
2022-01-21 07:42:01 +0100 <EvanR> a significant chunk of my errors are like that
2022-01-21 07:42:10 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 07:42:30 +0100 <EvanR> if this was HTML we wouldn't be bogged down by such
2022-01-21 07:42:33 +0100 <ephemient> ghc -fdeferred-type-errors -- yolo
2022-01-21 07:43:40 +0100 <zzz> pfft, i just write `main = main` and call it a day
2022-01-21 07:44:06 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 07:44:21 +0100 <EvanR> deriving BonanzaProfitMMORPG
2022-01-21 07:44:37 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 240 seconds)
2022-01-21 07:45:10 +0100 <zzz> interestingly, main = main typechecks...
2022-01-21 07:45:15 +0100 <EvanR> (I mean, it can't be that hard to get a formula for that)
2022-01-21 07:45:24 +0100 <ski> (why wouldn't it ?)
2022-01-21 07:45:39 +0100 <EvanR> how could it not*
2022-01-21 07:45:56 +0100 <ephemient> yeah, it would be more surprising if it *didn't* typecheck
2022-01-21 07:46:06 +0100 <zzz> main is supposed to be IO a
2022-01-21 07:46:18 +0100 <zzz> main = pure 7 doesn't
2022-01-21 07:46:21 +0100 <monochrom> HM type inference works in mysterious ways...
2022-01-21 07:46:22 +0100 <ski> @type let main :: IO a; main = main in main
2022-01-21 07:46:23 +0100 <lambdabot> IO a
2022-01-21 07:46:56 +0100 <ephemient> @type let main :: a; main = main in main :: IO ()
2022-01-21 07:46:57 +0100 <monochrom> main = pure 7 is fine.
2022-01-21 07:46:57 +0100 <lambdabot> IO ()
2022-01-21 07:46:59 +0100 <ski> @type let main :: IO Integer; main = pure 7 in main -- this also works
2022-01-21 07:47:00 +0100 <lambdabot> IO Integer
2022-01-21 07:47:09 +0100 <ski> (at the top-level, i mean)
2022-01-21 07:47:17 +0100 <ephemient> as long as there's some way to have main :: IO (), it's fine
2022-01-21 07:47:18 +0100 <zzz> you are right
2022-01-21 07:47:34 +0100 <EvanR> main = main has any type you want
2022-01-21 07:47:35 +0100 <ski> the result value is discarded. it doesn't have to have type `()'
2022-01-21 07:47:52 +0100 <monochrom> No you don't need ().
2022-01-21 07:48:17 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 07:49:49 +0100forell(~forell@user/forell) (Ping timeout: 240 seconds)
2022-01-21 07:50:39 +0100 <zzz> <<loop>>
2022-01-21 07:51:37 +0100xff0x(~xff0x@2001:1a81:52b8:8500:a7fd:d6d9:518c:9835) (Ping timeout: 240 seconds)
2022-01-21 07:52:41 +0100xff0x(~xff0x@2001:1a81:52b8:8500:bb40:636:eb26:d15a)
2022-01-21 07:52:42 +0100forell(~forell@user/forell)
2022-01-21 07:58:30 +0100 <zzz> monochrom: written in slide 65:
2022-01-21 07:58:31 +0100 <zzz> We could put in a list of Integer and get out a list of String
2022-01-21 07:58:32 +0100 <zzz> Which is impossible
2022-01-21 07:58:41 +0100 <zzz> "
2022-01-21 07:58:58 +0100 <zzz> well, it's not impossible, is it?
2022-01-21 07:59:02 +0100 <ski> (at least if it's actually sorting ..)
2022-01-21 08:01:27 +0100 <zzz> the problem with (Ord t) => [t] -> [a] is the forall a.
2022-01-21 08:01:32 +0100 <zzz> right?
2022-01-21 08:02:09 +0100 <ski> not sure what you mean
2022-01-21 08:03:06 +0100 <ski> it is an issue that the input element type is unrelated to the output element type
2022-01-21 08:04:15 +0100 <zzz> well, you could replace a with any type and it would be fine
2022-01-21 08:04:32 +0100faustind(~faustin@M014008067225.v4.enabler.ne.jp) ()
2022-01-21 08:06:12 +0100 <zzz> you can even just constraint, depending on the constraint
2022-01-21 08:07:12 +0100 <zzz> if all ts are sorted, return minBound, otherwise maxBound
2022-01-21 08:08:03 +0100 <ski> yea
2022-01-21 08:08:27 +0100 <ski> (although the latter does require an additional `Bounded a' constraint)
2022-01-21 08:08:41 +0100 <zzz> sure
2022-01-21 08:09:55 +0100 <ephemient> :t zipWith fst [0..] -- this is a function whose output element type has no relation to the input element type, but still does something (potentially) useful
2022-01-21 08:09:56 +0100 <lambdabot> (Num (b1 -> c, b2), Enum (b1 -> c, b2)) => [b1] -> [c]
2022-01-21 08:10:12 +0100 <ephemient> actually did I write that wrong, the type doesn't look like I expect
2022-01-21 08:10:17 +0100forell(~forell@user/forell) (Ping timeout: 240 seconds)
2022-01-21 08:10:20 +0100 <ski> `const' ?
2022-01-21 08:10:28 +0100 <ephemient> oh yeah
2022-01-21 08:10:42 +0100 <ephemient> :t zipWith const [0..]
2022-01-21 08:10:43 +0100 <lambdabot> (Num c, Enum c) => [b] -> [c]
2022-01-21 08:10:56 +0100skinods
2022-01-21 08:11:05 +0100 <ephemient> so it's not like it's totally unreasonable… it just doesn't make sense for sort
2022-01-21 08:12:38 +0100razetime(~quassel@49.207.203.87) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2022-01-21 08:13:38 +0100 <zzz> as long as you have constraints on the output type
2022-01-21 08:15:28 +0100 <zzz> my point is that no function can introduce a new unconstrained type variable on the output type
2022-01-21 08:16:04 +0100 <ski> well, the empty list has type `[a]', for any `a'
2022-01-21 08:16:47 +0100 <zzz> touche
2022-01-21 08:17:41 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 08:18:17 +0100mud(~mud@user/kadoban)
2022-01-21 08:18:43 +0100 <zzz> :t const Nothing
2022-01-21 08:18:44 +0100 <lambdabot> b -> Maybe a
2022-01-21 08:20:29 +0100nshepperd2(~nshepperd@li364-218.members.linode.com) (Read error: Connection reset by peer)
2022-01-21 08:20:30 +0100dumptruckman_(~dumptruck@45-79-173-88.ip.linodeusercontent.com)
2022-01-21 08:20:35 +0100dumptruckman(~dumptruck@45-79-173-88.ip.linodeusercontent.com) (Ping timeout: 250 seconds)
2022-01-21 08:20:41 +0100dumptruckman_dumptruckman
2022-01-21 08:20:51 +0100 <ksqsf> I just created a lambdacats sticker pack for Telegram users :-p
2022-01-21 08:20:57 +0100 <ksqsf> https://t.me/addstickers/lambdacats
2022-01-21 08:21:05 +0100edr(~edr@user/edr) (Ping timeout: 256 seconds)
2022-01-21 08:21:28 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 250 seconds)
2022-01-21 08:21:31 +0100nshepperd2(~nshepperd@li364-218.members.linode.com)
2022-01-21 08:21:47 +0100edr(~edr@enlo.co)
2022-01-21 08:21:47 +0100edr(~edr@enlo.co) (Changing host)
2022-01-21 08:21:47 +0100edr(~edr@user/edr)
2022-01-21 08:21:54 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 250 seconds)
2022-01-21 08:22:29 +0100_ht(~quassel@82-168-34-160.fixed.kpn.net)
2022-01-21 08:26:06 +0100nineonine(~nineonine@2604:3d08:7780:cd00:e983:291a:d390:4809) (Remote host closed the connection)
2022-01-21 08:26:30 +0100notzmv(~zmv@user/notzmv)
2022-01-21 08:28:52 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net)
2022-01-21 08:31:00 +0100ksqsf(~user@2001:da8:d800:336:ecbe:7994:fa3f:f03c) (Ping timeout: 250 seconds)
2022-01-21 08:36:31 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 08:36:37 +0100cheater(~Username@user/cheater) (Ping timeout: 240 seconds)
2022-01-21 08:37:08 +0100cheater(~Username@user/cheater)
2022-01-21 08:42:04 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2022-01-21 08:42:37 +0100slac83129(~slack1256@186.11.27.69) (Ping timeout: 240 seconds)
2022-01-21 08:44:44 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50) (Remote host closed the connection)
2022-01-21 08:45:02 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50)
2022-01-21 08:45:04 +0100Jing(~hedgehog@240e:390:7c53:a7e1:315f:3454:b0d8:112e)
2022-01-21 08:47:09 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-21 08:49:44 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50) (Remote host closed the connection)
2022-01-21 08:50:02 +0100cyphase(~cyphase@user/cyphase) (Ping timeout: 268 seconds)
2022-01-21 08:50:02 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50)
2022-01-21 08:50:28 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2022-01-21 08:53:39 +0100forell(~forell@user/forell)
2022-01-21 08:54:55 +0100cyphase(~cyphase@user/cyphase)
2022-01-21 08:56:05 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:ba7b:1b5c:238c:4447)
2022-01-21 08:59:51 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net)
2022-01-21 09:01:30 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 09:06:57 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 09:07:18 +0100fendor(~fendor@178.165.192.6.wireless.dyn.drei.com)
2022-01-21 09:07:29 +0100mc47(~mc47@xmonad/TheMC47)
2022-01-21 09:08:31 +0100alp(~alp@user/alp)
2022-01-21 09:08:42 +0100polyphem(~rod@2a02:810d:840:8754:b6f3:5141:3b3:83de) (Ping timeout: 250 seconds)
2022-01-21 09:09:01 +0100mbuf(~Shakthi@110.225.224.187) (Quit: Leaving)
2022-01-21 09:09:02 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 09:09:56 +0100ksqsf(~user@2001:da8:d800:336:807c:6844:3aff:5291)
2022-01-21 09:10:45 +0100MajorBiscuit(~MajorBisc@86-88-79-148.fixed.kpn.net)
2022-01-21 09:11:42 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2022-01-21 09:13:07 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 09:15:55 +0100Major_Biscuit(~MajorBisc@c-001-024-001.client.tudelft.eduvpn.nl)
2022-01-21 09:18:45 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2022-01-21 09:18:57 +0100MajorBiscuit(~MajorBisc@86-88-79-148.fixed.kpn.net) (Ping timeout: 240 seconds)
2022-01-21 09:19:51 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2022-01-21 09:23:52 +0100vpan(~0@212.117.1.172)
2022-01-21 09:25:34 +0100cfricke(~cfricke@user/cfricke)
2022-01-21 09:25:50 +0100polyphem(~rod@2a02:810d:840:8754:b6f3:5141:3b3:83de)
2022-01-21 09:25:57 +0100vysn(~vysn@user/vysn) (Ping timeout: 240 seconds)
2022-01-21 09:26:49 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 09:26:49 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 09:26:49 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 09:30:20 +0100dsrt^(~dsrt@207.182.73.202)
2022-01-21 09:31:55 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 09:33:58 +0100nshepperd2(~nshepperd@li364-218.members.linode.com) (Quit: Ping timeout (120 seconds))
2022-01-21 09:34:58 +0100joeyh(~joeyh@kitenet.net) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2022-01-21 09:35:10 +0100joeyh(joeyh@kitenet.net)
2022-01-21 09:36:13 +0100tomjaguarpaw(~tom@li367-225.members.linode.com) (Ping timeout: 240 seconds)
2022-01-21 09:37:17 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net) (Ping timeout: 240 seconds)
2022-01-21 09:37:35 +0100tureba(~tureba@tureba.org) (Ping timeout: 256 seconds)
2022-01-21 09:44:48 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 09:46:35 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-21 09:47:19 +0100tomjaguarpaw(~tom@li367-225.members.linode.com)
2022-01-21 09:48:36 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 09:49:34 +0100kuribas(~user@ptr-25vy0i8mxo9em8d53n7.18120a2.ip6.access.telenet.be)
2022-01-21 09:49:55 +0100Flonk(~Flonk@vps-zap441517-1.zap-srv.com) (Quit: Ping timeout (120 seconds))
2022-01-21 09:49:59 +0100tureba(~tureba@tureba.org)
2022-01-21 09:50:21 +0100Flonk(~Flonk@vps-zap441517-1.zap-srv.com)
2022-01-21 09:50:45 +0100machinedgod(~machinedg@24.105.81.50)
2022-01-21 09:50:53 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2022-01-21 09:51:24 +0100nshepperd2(~nshepperd@li364-218.members.linode.com)
2022-01-21 09:52:28 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2022-01-21 09:52:58 +0100Guest5225(~Guest52@80-100-97-100.ip.xs4all.nl)
2022-01-21 09:54:43 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net)
2022-01-21 09:57:30 +0100ph88(~ph88@2a01:598:d003:cd60:6db8:d93b:1b5e:cf50) (Read error: Connection reset by peer)
2022-01-21 09:57:52 +0100ph88(~ph88@2a02:8109:9e00:71d0:e821:f261:3387:e512)
2022-01-21 09:59:41 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net) (Ping timeout: 256 seconds)
2022-01-21 10:00:21 +0100phma(phma@2001:5b0:212a:d158:6462:9429:37ae:1dd1) (Read error: Connection reset by peer)
2022-01-21 10:01:14 +0100phma(phma@2001:5b0:211b:b1e8:ef4c:8052:a169:f66a)
2022-01-21 10:03:38 +0100Codaraxis(~Codaraxis@user/codaraxis)
2022-01-21 10:03:50 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2022-01-21 10:06:14 +0100mmhat(~mmh@55d4fecc.access.ecotel.net)
2022-01-21 10:06:38 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2022-01-21 10:06:40 +0100Codaraxis_(~Codaraxis@user/codaraxis) (Ping timeout: 256 seconds)
2022-01-21 10:16:22 +0100andjjj23_(~irc@107.170.228.47) (Ping timeout: 268 seconds)
2022-01-21 10:17:01 +0100c_wraith(~c_wraith@adjoint.us) (Ping timeout: 240 seconds)
2022-01-21 10:17:15 +0100fluxit(~fluxit@techsmix.net) (Ping timeout: 256 seconds)
2022-01-21 10:17:15 +0100mmaruseacph2(~mihai@198.199.100.72) (Ping timeout: 256 seconds)
2022-01-21 10:17:15 +0100meejah(~meejah@rutas.meejah.ca) (Ping timeout: 256 seconds)
2022-01-21 10:17:44 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2022-01-21 10:17:44 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2022-01-21 10:17:47 +0100allbery_bgeekosaur
2022-01-21 10:18:18 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net)
2022-01-21 10:18:47 +0100meejah(~meejah@rutas.meejah.ca)
2022-01-21 10:18:55 +0100mmaruseacph2(~mihai@198.199.100.72)
2022-01-21 10:22:01 +0100fluxit(~fluxit@techsmix.net)
2022-01-21 10:22:24 +0100c_wraith(~c_wraith@adjoint.us)
2022-01-21 10:25:57 +0100noctux(~noctux@user/noctux) (Read error: Connection reset by peer)
2022-01-21 10:26:47 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 10:28:19 +0100mud(~mud@user/kadoban) (Remote host closed the connection)
2022-01-21 10:28:45 +0100mud(~mud@user/kadoban)
2022-01-21 10:29:55 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2022-01-21 10:30:42 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net)
2022-01-21 10:30:57 +0100fluxit(~fluxit@techsmix.net) (Ping timeout: 240 seconds)
2022-01-21 10:31:02 +0100c_wraith(~c_wraith@adjoint.us) (Ping timeout: 256 seconds)
2022-01-21 10:31:42 +0100andjjj23_(~irc@107.170.228.47)
2022-01-21 10:31:49 +0100c_wraith(~c_wraith@adjoint.us)
2022-01-21 10:32:40 +0100nsilv-phone(~nsilv-pho@host-213-45-115-140.pool21345.interbusiness.it)
2022-01-21 10:32:46 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 250 seconds)
2022-01-21 10:32:49 +0100nsilv-phone(~nsilv-pho@host-213-45-115-140.pool21345.interbusiness.it) (Client Quit)
2022-01-21 10:33:43 +0100fluxit(~fluxit@techsmix.net)
2022-01-21 10:34:27 +0100ubert1(~Thunderbi@p200300ecdf09943ef05cebfd8a506150.dip0.t-ipconnect.de)
2022-01-21 10:34:34 +0100max22-(~maxime@lfbn-ren-1-1026-62.w92-139.abo.wanadoo.fr)
2022-01-21 10:35:43 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-21 10:35:48 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 10:36:16 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 10:40:08 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 250 seconds)
2022-01-21 10:42:36 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 10:42:36 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 10:42:36 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 10:43:41 +0100noctux(~noctux@user/noctux)
2022-01-21 10:45:03 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net) (Remote host closed the connection)
2022-01-21 10:46:38 +0100tomjaguarpaw(~tom@li367-225.members.linode.com) (Ping timeout: 250 seconds)
2022-01-21 10:46:45 +0100tomjaguarpaw(~tom@li367-225.members.linode.com)
2022-01-21 10:47:30 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-21 10:49:00 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 10:52:32 +0100Jing(~hedgehog@240e:390:7c53:a7e1:315f:3454:b0d8:112e) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2022-01-21 10:53:17 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Ping timeout: 240 seconds)
2022-01-21 10:53:37 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 240 seconds)
2022-01-21 10:58:37 +0100c_wraith(~c_wraith@adjoint.us) (Ping timeout: 256 seconds)
2022-01-21 10:58:37 +0100xff0x(~xff0x@2001:1a81:52b8:8500:bb40:636:eb26:d15a) (Ping timeout: 240 seconds)
2022-01-21 10:58:48 +0100mmaruseacph2(~mihai@198.199.100.72) (Ping timeout: 256 seconds)
2022-01-21 10:59:52 +0100xff0x(~xff0x@2001:1a81:52b8:8500:6c95:ecd6:fb54:75ad)
2022-01-21 11:00:30 +0100vglfr(~vglfr@88.155.98.86) (Ping timeout: 256 seconds)
2022-01-21 11:01:31 +0100vglfr(~vglfr@46.96.174.179)
2022-01-21 11:01:58 +0100Jing(~hedgehog@240e:390:7c53:a7e1:81fd:e333:1e93:e27e)
2022-01-21 11:02:31 +0100ksqsf(~user@2001:da8:d800:336:807c:6844:3aff:5291) (Remote host closed the connection)
2022-01-21 11:03:15 +0100c_wraith(~c_wraith@adjoint.us)
2022-01-21 11:03:54 +0100meejah(~meejah@rutas.meejah.ca) (Ping timeout: 256 seconds)
2022-01-21 11:03:57 +0100fluxit(~fluxit@techsmix.net) (Ping timeout: 240 seconds)
2022-01-21 11:09:00 +0100andjjj23_(~irc@107.170.228.47) (Ping timeout: 256 seconds)
2022-01-21 11:09:36 +0100c_wraith(~c_wraith@adjoint.us) (Ping timeout: 250 seconds)
2022-01-21 11:10:14 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-21 11:11:05 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 11:13:42 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-21 11:14:18 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2022-01-21 11:21:30 +0100DNH(~DNH@2a02:8108:1100:16d8:b4f2:7b49:1758:11bf)
2022-01-21 11:22:19 +0100andjjj23_(~irc@107.170.228.47)
2022-01-21 11:22:57 +0100fluxit(~fluxit@techsmix.net)
2022-01-21 11:23:04 +0100c_wraith(~c_wraith@adjoint.us)
2022-01-21 11:23:14 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Quit: So long and thanks for all the fish)
2022-01-21 11:25:26 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 256 seconds)
2022-01-21 11:26:57 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 256 seconds)
2022-01-21 11:27:44 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-21 11:27:49 +0100 <romesrf> hey everyone
2022-01-21 11:28:03 +0100 <romesrf> in type UniqResult result = (# result, UniqSupply #), what are the ### called?
2022-01-21 11:28:07 +0100meejah(~meejah@rutas.meejah.ca)
2022-01-21 11:28:19 +0100 <ski> that's an unboxed tuple type
2022-01-21 11:28:25 +0100 <romesrf> thank you :)
2022-01-21 11:29:06 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 250 seconds)
2022-01-21 11:29:34 +0100__monty__(~toonn@user/toonn)
2022-01-21 11:31:09 +0100mgd(~mgd@85.210.231.115)
2022-01-21 11:38:27 +0100vysn(~vysn@user/vysn)
2022-01-21 11:39:28 +0100mechano(~mechano@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net)
2022-01-21 11:40:27 +0100 <mechano> how do lexers and parsers work? is that some kind of formal methods thing, since its like language design?
2022-01-21 11:41:16 +0100DNH(~DNH@2a02:8108:1100:16d8:b4f2:7b49:1758:11bf) (Quit: Textual IRC Client: www.textualapp.com)
2022-01-21 11:41:51 +0100 <mechano> there must be some kind of low dimensional space somewhere, and that the language design must somehow target that
2022-01-21 11:42:45 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 11:43:31 +0100 <mechano> i was thinking of an example like describing rhythms, where repetition and variation instructions are normally given. basically this gives a language to produce binary sequences, and i was wondering how this compared to a proper programming language.
2022-01-21 11:44:01 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2022-01-21 11:44:04 +0100 <__monty__> It's more a mechanical recognizing of character sequences.
2022-01-21 11:44:37 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2022-01-21 11:45:18 +0100Lord_of_Life_Lord_of_Life
2022-01-21 11:45:48 +0100 <mechano> here the low dimensional space is that rhythms are something to do with how the brain expects a repeated sound, because of how it processes vocal tones (im guessing) - and that this gives the language, which people have somehow naturally determined...
2022-01-21 11:46:02 +0100 <[exa]> mechano: lexers and parsers are usually formalized as programs that compute matches to regular and context-free languages
2022-01-21 11:46:10 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 11:46:30 +0100 <[exa]> mechano: rhytms are much more lattice-like and the definition is waaaaaaaaaaaaaay softer
2022-01-21 11:46:33 +0100 <mechano> [exa] its just like an encoder and a decoder right? like, an autoencoder...
2022-01-21 11:46:48 +0100 <[exa]> not really
2022-01-21 11:47:02 +0100 <mechano> its different because its streaming?
2022-01-21 11:47:38 +0100 <mechano> [exa]: no? i thought it was just a basis rotation...
2022-01-21 11:47:38 +0100 <[exa]> I wouldn't use neural network methodology to describe the parsing, although you can technically "wire" the regular parsers and limited-depth context-free parsers to neural networks
2022-01-21 11:48:11 +0100mgd(~mgd@85.210.231.115) ()
2022-01-21 11:48:36 +0100 <mechano> sure, there is some mismatch between the soft classifiers and the binary case
2022-01-21 11:49:14 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 11:49:30 +0100 <mechano> i guess the main differernce is that a language isnt a black box parametric model, and that all of the design variables are comprehensible
2022-01-21 11:50:01 +0100 <[exa]> also NNs are tremendously inefficient compared to parsers that you can automatically define from a formal language spec (regex/automaton, CF grammar, ...)
2022-01-21 11:50:14 +0100 <[exa]> yeah, no blackboxes
2022-01-21 11:50:40 +0100SummerSonw(~The_viole@203.77.49.232) (Remote host closed the connection)
2022-01-21 11:51:00 +0100 <mechano> so this spec is giving a test case, that arbitrary implementation can be shown equivalent under?
2022-01-21 11:51:03 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-21 11:51:18 +0100 <mechano> ok, i guess i should speak in terms of language specifications then
2022-01-21 11:51:22 +0100 <[exa]> let's continue in #haskell-offtopic, can we? this is getting offtopic :D
2022-01-21 11:51:37 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 11:51:41 +0100 <mechano> where does the formal methods part end, i dont want to stray offtopic
2022-01-21 11:52:07 +0100 <[exa]> like, this is getting to automata & grammar theory which is kinda offtopic anyway :D
2022-01-21 11:52:16 +0100 <[exa]> no big worries I guess tho
2022-01-21 11:52:49 +0100 <[exa]> the point is that spec is not giving a test case, it is a complete, always decidable specification of what is in a language and what isn't
2022-01-21 11:53:08 +0100 <mechano> so how does haskell fit in to all this? i mean, i was just using a simple example to try to understand how an actual language can be described
2022-01-21 11:53:37 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2022-01-21 11:53:54 +0100 <[exa]> haskell has a quite complicated context-free grammar, you might find the "specifications" in GHC source, likely as alex/happy parser source code
2022-01-21 11:54:26 +0100mmaruseacph2(~mihai@198.199.100.72)
2022-01-21 11:55:37 +0100 <[exa]> https://github.com/ghc/ghc/blob/master/compiler/GHC/Parser/Lexer.x eg here
2022-01-21 11:55:46 +0100 <mechano> im struggling to get the difference between a basis transformation, eg a matrix in linear algebra, and the compilation and program writing process as a kind of similar bijection. is the specification fulfilling the same role as the matrix parameters?
2022-01-21 11:56:34 +0100 <[exa]> the difference is that compiling program by basis transoformation is theoretically possible but a total madness to do correctly
2022-01-21 11:56:37 +0100 <mechano> [exa] wait, why does haskell use happy & alex? what are those, how do they work here?
2022-01-21 11:57:13 +0100 <ephemient> alex : happy :: lex : yacc
2022-01-21 11:57:54 +0100 <mechano> ephemient: im not sure what that means
2022-01-21 11:57:56 +0100 <[exa]> mechano: are you aware of the finite-state machine theory, pushdown automata, etc?
2022-01-21 11:58:09 +0100 <mechano> im guessing that the parser has some state
2022-01-21 11:58:24 +0100 <mechano> during a fold that consumes the program string
2022-01-21 11:58:45 +0100 <ephemient> alex is to happy as lex is to yacc. lex and yacc are well-known lexers and parser generators in old-school compilers, alex and happy fulfill similar roles in Haskell
2022-01-21 11:58:46 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 11:59:07 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-21 11:59:11 +0100 <mechano> and undergoes a state action that is the "automata" update
2022-01-21 11:59:23 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 11:59:44 +0100 <[exa]> mechano: yep. you can encode that to linear algebra but it gets unwieldy
2022-01-21 12:01:16 +0100 <mechano> im guessing the problem is that there is a large number of discrete values, and you would need an orthogonal vector for each, but i can almost see how that might end up as a matrix!
2022-01-21 12:01:37 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 12:01:56 +0100 <mechano> i dont like trying to understand the vector space version of logic..
2022-01-21 12:02:12 +0100 <mechano> id rather just think of it as a bijection
2022-01-21 12:02:46 +0100 <[exa]> yeah, given e.g. a DFA you can work in Z(2) with 1-bit representation of the state, and each letter causes multiplication by a matrix that describes all transitions caused by the letter
2022-01-21 12:02:57 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-21 12:03:05 +0100 <[exa]> and you accept if there's '1' in the expected finishing states
2022-01-21 12:03:06 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:03:15 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 12:03:22 +0100Codaraxis_(~Codaraxis@user/codaraxis)
2022-01-21 12:03:25 +0100 <mechano> ephemient: so alex is a lexer? and happy is a parser?
2022-01-21 12:03:31 +0100Codaraxis(~Codaraxis@user/codaraxis) (Read error: Connection reset by peer)
2022-01-21 12:04:03 +0100 <[exa]> normal parser state machines have "stacks" (ie. infinite memory) which is impossible to do easily, but you can convert limited-depth stack machine to DFAs and go the same way
2022-01-21 12:04:23 +0100 <[exa]> ending up with matrices like 10000000x10000000 for parsing haskell
2022-01-21 12:04:41 +0100 <ephemient> a parser generator. you give it a grammar and it spits out Haskell code
2022-01-21 12:04:43 +0100 <mechano> ah, right, part of this was supposed to be to do with brevity
2022-01-21 12:05:25 +0100 <[exa]> (I'm assuming there are no shenanigans (there are) and no lookahead)
2022-01-21 12:05:26 +0100 <mechano> like, a good language would somehow be effecient, somehow using the shape of the low dimensional space "good programs" inhabit
2022-01-21 12:05:57 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-21 12:06:24 +0100 <[exa]> I don't want to see the size of the matrix that would be needed to represent the whole program transformations done by even a relatively tiny compiler, such as tcc
2022-01-21 12:06:29 +0100 <mechano> ephemient: sounds more like a lexer that outputs parser, which seems confusing
2022-01-21 12:06:31 +0100 <[exa]> you won't fit it on earth IMO
2022-01-21 12:06:56 +0100 <mechano> so how does the compiler end up being so elegant?
2022-01-21 12:07:06 +0100 <mechano> is that because its a good language?
2022-01-21 12:07:22 +0100 <[exa]> it avoids expressing problems in inefficient ways
2022-01-21 12:07:27 +0100 <mechano> or because its written in a good language? im still slightly confused about the stages ere
2022-01-21 12:07:32 +0100Codaraxis_(~Codaraxis@user/codaraxis) (Read error: Connection reset by peer)
2022-01-21 12:07:56 +0100 <[exa]> linear algebra is simply not an efficient way to work with complicated exact language structures and ASTs.
2022-01-21 12:07:57 +0100Codaraxis_(~Codaraxis@user/codaraxis)
2022-01-21 12:08:32 +0100 <mechano> something to do with them being consumed in an ordered way?
2022-01-21 12:08:54 +0100 <[exa]> same with neural nets, you can express the learning task as precise boolean logic problem, but no one does that because the complexity of doing it that way would be completely hopeless
2022-01-21 12:09:02 +0100 <mechano> you only get left to right determinism then... but i cant see that being responsible for the most part of the savings
2022-01-21 12:09:50 +0100 <mechano> i think im missing something about what makes a good language, or a good program, or something
2022-01-21 12:10:15 +0100 <[exa]> did you do any computational complexity theory?
2022-01-21 12:10:16 +0100 <mechano> seems like theres something to do with compiler complexity, ie not just a big matrix
2022-01-21 12:10:34 +0100 <[exa]> inverting compilers is NP
2022-01-21 12:10:37 +0100 <mechano> [exa] i never heard of it, so im guessing not, but the ideas are probably familiar
2022-01-21 12:10:57 +0100 <[exa]> (ok maybe much harder than NP)
2022-01-21 12:11:08 +0100 <mechano> [exa] thats basically impossibly hard, iiuc
2022-01-21 12:11:53 +0100 <[exa]> yeah it very easily belongs to some class of problems that you just can't expect to solve in humane times
2022-01-21 12:11:53 +0100 <mechano> so you need to use the spec to give the lexer and parser (compiler), and not try to infer the spec from the compiler? is that what your saying?
2022-01-21 12:12:19 +0100 <[exa]> lexer and parser _are_ the compiler
2022-01-21 12:12:24 +0100 <mechano> how is that to do with what makes a good language?
2022-01-21 12:12:32 +0100 <[exa]> nothing honestly
2022-01-21 12:12:40 +0100 <mechano> wait, i thought the compiler was just a parser, and that the programmer was the lexer
2022-01-21 12:12:41 +0100 <[exa]> people choose whatever language they like
2022-01-21 12:12:41 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net)
2022-01-21 12:12:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 12:13:02 +0100 <[exa]> anyway we're now seriously offtopic :D
2022-01-21 12:13:02 +0100 <mechano> im not sure why you were mentioning inverting compilers
2022-01-21 12:13:22 +0100 <[exa]> you wanted a bijection right?
2022-01-21 12:13:37 +0100 <mechano> i guess ill never understand how haskell was an eloquent bijection
2022-01-21 12:13:46 +0100 <[exa]> because it's not
2022-01-21 12:14:25 +0100 <mechano> but it describes the format targeted by the programmer and compiler
2022-01-21 12:14:46 +0100 <mechano> which seem to be the transformation and its inverse
2022-01-21 12:14:55 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 12:15:31 +0100 <mechano> yeah, at this point ill accept im not going to understand which parts of this are ontopic and just give up!
2022-01-21 12:15:34 +0100 <mechano> but thanks
2022-01-21 12:15:49 +0100 <[exa]> the "seem to be" there is too vague honestly. :D
2022-01-21 12:16:07 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:16:13 +0100 <mechano> well im not sure, so...
2022-01-21 12:18:19 +0100 <mechano> all i was trying to say is that haskell must somehow compress program size, by being a "good" language
2022-01-21 12:18:27 +0100 <[exa]> like, maybe we're just talking different languages now; check out some of the formal material on compilers, and some of the complexity theory (where these representation transformations are quite common) I guess you might find an answer there
2022-01-21 12:18:42 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-21 12:18:46 +0100 <[exa]> ah, you meant "expressive"
2022-01-21 12:19:01 +0100 <mechano> oh is that what that means!?
2022-01-21 12:19:09 +0100 <[exa]> that is also double sided, check out APL. :D
2022-01-21 12:19:49 +0100 <mechano> this? https://en.wikipedia.org/wiki/APL_(programming_language)
2022-01-21 12:19:54 +0100 <mechano> what am i looking for?
2022-01-21 12:19:57 +0100 <[exa]> anyway there is no good metric on how to measure this AFAIK, especially not with bijections and linear algebra because the "expansion" process is just wicked complex
2022-01-21 12:20:24 +0100 <[exa]> yeah that was my anti-example to "compress program size"
2022-01-21 12:20:45 +0100 <mechano> i guess trying to understand what makes a language good would be like trying to understand the "most common shaped programs" or something
2022-01-21 12:21:14 +0100 <[exa]> Haskell does the expansion basically by embedding a few layers of extra logic above the actual program logic and programmer may exploit these to do complicated stuff in the lower layers quickly
2022-01-21 12:21:15 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2022-01-21 12:21:47 +0100 <mechano> like how i can say that describing drumbeats as repititions and variations is a good idea, because most of the common patterns inhabit the small space where repetition and variation are used a lot, and those kind of instructions allow lots of data to be generated from short statements
2022-01-21 12:21:59 +0100 <[exa]> ah, that doesn't work on programs
2022-01-21 12:22:29 +0100 <[exa]> similarity of programs as a metric is completely impossible to do right, because the interpretation is binary
2022-01-21 12:23:00 +0100 <[exa]> (see e.g. rice's theorem)
2022-01-21 12:23:09 +0100 <mechano> but like, many programs are recursive. i guess that gets a whole bunch
2022-01-21 12:23:22 +0100alt-romes(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-21 12:23:27 +0100 <mechano> i think i could be wrongly thinking in terms of higher order programs though
2022-01-21 12:23:29 +0100 <[exa]> s/binary/complicated and totally not smooth/
2022-01-21 12:24:34 +0100 <mechano> that sounds like Russels paradox almost...
2022-01-21 12:24:38 +0100 <[exa]> anyway re drum patterns, these have some representation in grammars as well (there might be nice papers on that), but the interpretation there is completely different
2022-01-21 12:24:49 +0100 <mechano> how so?
2022-01-21 12:24:56 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 12:24:58 +0100 <johnjaye> what's the correct way to update cabal to 3.0+?
2022-01-21 12:25:06 +0100 <[exa]> no one really knows how brains listen to that
2022-01-21 12:25:08 +0100 <mechano> because its just a binary sequence?
2022-01-21 12:25:19 +0100 <johnjaye> this ubuntu pc apparently only has 2.x in the repos
2022-01-21 12:25:21 +0100 <[exa]> johnjaye: I just downloaded the new cabal binary and put it in $PATH...
2022-01-21 12:25:39 +0100 <johnjaye> from like the git release page or?
2022-01-21 12:25:51 +0100 <[exa]> johnjaye: chances are you might be better off with a ghc+cabal installed by `ghcup` instead of the ones from ubuntu/debian repositories
2022-01-21 12:26:10 +0100 <__monty__> [exa]: Isn't Haskell's layout grammar actually case-sensitive?
2022-01-21 12:26:17 +0100incertia(~incertia@24.42.229.53)
2022-01-21 12:26:20 +0100 <__monty__> Not case, context >.<
2022-01-21 12:26:27 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt) (Ping timeout: 256 seconds)
2022-01-21 12:26:42 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 12:26:59 +0100 <johnjaye> do i need to update cabal? it gave me a message about v1/v2 deprecation but
2022-01-21 12:27:05 +0100 <mechano> [exa] yeah, well, i think the *main thing* is this idea of addaptive classfiers that become context aware, becoming sensitized by recent observations. basically you end up with some idea of "knowing what to expect" and this entering into the classification process. hence repitition in music is a kind of neuroscientifically understandable phenomina.
2022-01-21 12:27:05 +0100 <mechano> (now *thats* offtopic!)
2022-01-21 12:27:10 +0100 <johnjaye> it seems it's updating
2022-01-21 12:27:10 +0100 <[exa]> johnjaye: the repository ones are kept for compatibility and ubuntu, for development it's better to just install your own :]
2022-01-21 12:27:25 +0100 <johnjaye> ok
2022-01-21 12:28:02 +0100 <[exa]> johnjaye: anyway the v2 should be okay for some time, you might be able to find v3.x in .deb somewhere (I guess debian testing/unstable repos?), but generally I'd really recommend to just remove system cabal+ghc and go with ghcup
2022-01-21 12:28:04 +0100 <johnjaye> specifically i tried to run ministg and got the error [__1] unknown package: monads-tf (dependency of ministg)
2022-01-21 12:28:46 +0100perrierjouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca) (Quit: WeeChat 3.4)
2022-01-21 12:28:53 +0100 <mechano> the point being just that repitition & variation as a grammer for drumpattens is kind of rationalizable. but i still cant understand how that idea carries over to haskell, about what programs we can expect, and how this governs the language we end up using
2022-01-21 12:29:36 +0100sheb(~sheb@31.223.228.71)
2022-01-21 12:29:43 +0100 <mechano> but i suppose most languages dont even have functions as first class citizens, so i guess they are way behind
2022-01-21 12:29:56 +0100 <mechano> i wonder how impactful all of this stuff is
2022-01-21 12:30:04 +0100 <mechano>  /important
2022-01-21 12:30:04 +0100 <[exa]> mechano: spoiler: the idea doesn't really carry easily to haskell. If you are trying to determine how humans perceive the haskell programs and why it is nice for them, you'll need to go super deep to neuroscience and you might have like 20 years of work to do, likely getting 2 or 3 PhDs in the process :D
2022-01-21 12:30:33 +0100 <mechano> huh, then i might be able to describe it nicely
2022-01-21 12:31:00 +0100 <mechano> without resorting to category theoretic string theory constructions!
2022-01-21 12:31:14 +0100 <mechano> *muhaha* - ok im offski
2022-01-21 12:31:17 +0100 <[exa]> there might be some work done on that topic, try going to scholar.google.com and find a few papers
2022-01-21 12:31:21 +0100mechano(~mechano@cpc101088-sgyl37-2-0-cust22.18-2.cable.virginm.net) (Quit: Connection closed)
2022-01-21 12:31:58 +0100 <[exa]> johnjaye: `cabal update` didn't fix that? (that downloads a new database of packages)
2022-01-21 12:32:00 +0100 <johnjaye> er... so ghcup just downloads binaries?
2022-01-21 12:32:06 +0100 <johnjaye> [exa]: correct
2022-01-21 12:32:33 +0100 <johnjaye> it printed Downloading the latest package list from hackage.haskell.org then returned
2022-01-21 12:33:06 +0100 <[exa]> if it still fails then, I'd expect some realistic versioning problems that might be fixed with newer cabal, but I don't know much of the packages, really guessing now
2022-01-21 12:33:31 +0100 <[exa]> ghcup is kinda like rustup, it downloads you a working environment, puts everything in the $PATH right, and provides an easy tool to get newer versions of the tools
2022-01-21 12:33:42 +0100 <johnjaye> you know as much as i do.
2022-01-21 12:33:44 +0100 <johnjaye> https://hackage.haskell.org/package/ministg
2022-01-21 12:34:41 +0100 <[exa]> perhaps try to pastebin the whole error message
2022-01-21 12:34:51 +0100 <[exa]> someone here could recognize the problem
2022-01-21 12:35:02 +0100[exa]-> afk
2022-01-21 12:35:13 +0100 <johnjaye> https://bpa.st/4BMQ
2022-01-21 12:35:19 +0100 <johnjaye> yup thanks
2022-01-21 12:35:34 +0100 <johnjaye> this is ubuntu 20.04 so i'm surprised it's that out of date sof ast
2022-01-21 12:36:57 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:40:42 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt)
2022-01-21 12:40:48 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 256 seconds)
2022-01-21 12:41:33 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2022-01-21 12:41:52 +0100juhp(~juhp@128.106.188.82) (Quit: juhp)
2022-01-21 12:42:37 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 12:42:53 +0100alt-romes(~romes@44.190.189.46.rev.vodafone.pt) (Ping timeout: 256 seconds)
2022-01-21 12:44:11 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:47:57 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-21 12:48:09 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 12:49:48 +0100fef(~thedawn@user/thedawn)
2022-01-21 12:52:56 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:53:36 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-21 12:54:18 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 12:54:50 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 12:54:54 +0100 <byorgey> Does the Hackage Matrix Builder website work for anyone else? e.g. https://matrix.hackage.haskell.org/#/package/disco when I visit it, it's just blank.
2022-01-21 12:55:21 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 12:55:31 +0100 <__monty__> The HTML has an empty body for me too.
2022-01-21 12:56:11 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 12:56:57 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-21 12:57:04 +0100 <__monty__> johnjaye: Hmm, and this is after running cabal update?
2022-01-21 12:58:12 +0100 <johnjaye> yes. ghcup finished and i'm using that instead
2022-01-21 12:58:41 +0100 <johnjaye> with that it compiled a bunch of things
2022-01-21 12:59:21 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 12:59:21 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 12:59:21 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 12:59:24 +0100 <johnjaye> hrm. ok
2022-01-21 12:59:30 +0100 <johnjaye> so the final result is in... ./dist-newstyle/build/x86_64-linux/ghc-8.10.7/ministg-0.3/x/ministg/build/ministg/ministg
2022-01-21 12:59:35 +0100 <johnjaye> is that... normal?
2022-01-21 13:04:16 +0100 <c_wraith> yes
2022-01-21 13:04:25 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 13:04:25 +0100johnjaye(~pi@173.209.65.233) (Ping timeout: 256 seconds)
2022-01-21 13:04:27 +0100 <c_wraith> you aren't supposed to ever type that out :)
2022-01-21 13:04:37 +0100 <Clint> he pinged out, he was so upset
2022-01-21 13:06:10 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 250 seconds)
2022-01-21 13:07:34 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 13:08:34 +0100ncopa3(~ncopa@gbr2-dev1.alpinelinux.org)
2022-01-21 13:15:11 +0100vglfr(~vglfr@46.96.174.179) (Ping timeout: 256 seconds)
2022-01-21 13:17:33 +0100ncopa3(~ncopa@gbr2-dev1.alpinelinux.org) (Quit: Alpine Linux, the security-oriented, lightweight Linux distribution)
2022-01-21 13:17:57 +0100ncopa3(~ncopa@gbr2-dev1.alpinelinux.org)
2022-01-21 13:22:37 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 240 seconds)
2022-01-21 13:23:46 +0100dut(~dut@user/dut) (Quit: Leaving)
2022-01-21 13:26:07 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 13:28:59 +0100 <geekosaur> byorgey, matrix builder is dead, nobody knows how to resurrect it
2022-01-21 13:29:57 +0100 <geekosaur> I asked about it and got pointed to a big pile of hvr code that I'd have to mindmeld with to understand :/
2022-01-21 13:34:26 +0100perrierjouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca)
2022-01-21 13:37:29 +0100 <maerwald[m]> xD
2022-01-21 13:38:10 +0100vglfr(~vglfr@46.96.174.179)
2022-01-21 13:38:28 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Read error: Connection reset by peer)
2022-01-21 13:38:34 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 13:39:04 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 13:40:03 +0100nunggu(~q@user/nunggu) (Ping timeout: 276 seconds)
2022-01-21 13:40:38 +0100Codaraxis_(~Codaraxis@user/codaraxis) (Quit: Leaving)
2022-01-21 13:41:32 +0100nunggu(~q@user/nunggu)
2022-01-21 13:42:57 +0100michalz(~michalz@185.246.204.43) (Ping timeout: 256 seconds)
2022-01-21 13:43:13 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-21 13:43:34 +0100Morrow_(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-21 13:43:49 +0100michalz(~michalz@185.246.204.58)
2022-01-21 13:48:30 +0100nunggu(~q@user/nunggu) (Ping timeout: 276 seconds)
2022-01-21 13:48:30 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao) (Ping timeout: 276 seconds)
2022-01-21 13:51:45 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-21 13:51:57 +0100CiaoSen(~Jura@p200300c95737a2002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2022-01-21 13:56:31 +0100max22-(~maxime@lfbn-ren-1-1026-62.w92-139.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-21 13:56:34 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2022-01-21 13:56:52 +0100xb0o2(~xb0o2@user/xb0o2)
2022-01-21 13:59:41 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net)
2022-01-21 14:04:29 +0100yauhsien_(~yauhsien@61-231-62-246.dynamic-ip.hinet.net) (Ping timeout: 256 seconds)
2022-01-21 14:05:12 +0100nunggu(~q@user/nunggu)
2022-01-21 14:10:58 +0100fendor_(~fendor@178.115.77.166.wireless.dyn.drei.com)
2022-01-21 14:11:17 +0100incertia(~incertia@24.42.229.53) (Read error: Connection reset by peer)
2022-01-21 14:13:33 +0100fendor(~fendor@178.165.192.6.wireless.dyn.drei.com) (Ping timeout: 256 seconds)
2022-01-21 14:19:16 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-21 14:19:36 +0100ec(~ec@gateway/tor-sasl/ec) (Client Quit)
2022-01-21 14:23:39 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 268 seconds)
2022-01-21 14:24:48 +0100geranim0(~geranim0@modemcable242.171-178-173.mc.videotron.ca)
2022-01-21 14:26:27 +0100justsomeguy(~justsomeg@user/justsomeguy)
2022-01-21 14:27:48 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net)
2022-01-21 14:29:04 +0100xkuru(~xkuru@user/xkuru)
2022-01-21 14:32:03 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 14:32:14 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it)
2022-01-21 14:39:51 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-21 14:42:37 +0100alp(~alp@user/alp) (Ping timeout: 240 seconds)
2022-01-21 14:43:17 +0100max22-(~maxime@2a01cb088335980025090258985cbdb2.ipv6.abo.wanadoo.fr)
2022-01-21 14:46:23 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it) (Read error: Connection reset by peer)
2022-01-21 14:47:24 +0100slack1256(~slack1256@191.125.227.213)
2022-01-21 14:51:37 +0100cfricke(~cfricke@user/cfricke) (Ping timeout: 240 seconds)
2022-01-21 14:52:08 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it)
2022-01-21 14:52:25 +0100incertia(~incertia@207.98.176.56)
2022-01-21 14:52:27 +0100alp(~alp@user/alp)
2022-01-21 14:54:51 +0100hrdl(~hrdl@mail.hrdl.eu) ()
2022-01-21 14:58:48 +0100ksqsf(~user@2001:da8:d800:611:7915:1763:796:9db6)
2022-01-21 15:00:19 +0100Guest5225(~Guest52@80-100-97-100.ip.xs4all.nl) (Quit: Connection closed)
2022-01-21 15:00:22 +0100 <merijn> after much study I think the solution to my problem is to use a Bounding Volume Hierarchy. Sadly, finding a good explanation of how to construct those is hard to find. I don't suppose anyone here knows a good introduction? :p
2022-01-21 15:00:35 +0100Guest5261(~Guest52@80-100-97-100.ip.xs4all.nl)
2022-01-21 15:00:45 +0100 <[exa]> merijn: what was the problem btw?
2022-01-21 15:02:20 +0100 <merijn> [exa]: I have a large volume partitioned into sub-volumes (hypercuboids?) where each sub-volume has a corresponding value, the problem is: Given a point what is the value associated with the subvolume the point falls in
2022-01-21 15:03:23 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it) (Remote host closed the connection)
2022-01-21 15:03:30 +0100 <[exa]> there's no hierarchy in the subvolumes right?
2022-01-21 15:03:46 +0100 <c_wraith> Is a bounding volume hierarchy a generalization of quadtree/octree/etc?
2022-01-21 15:03:48 +0100 <merijn> [exa]: There is no overlap no, so not really
2022-01-21 15:03:54 +0100 <merijn> c_wraith: Not quite
2022-01-21 15:04:05 +0100 <merijn> c_wraith: kd-trees are a generalisation of those
2022-01-21 15:04:35 +0100 <[exa]> everything is axis aligned?
2022-01-21 15:04:51 +0100 <merijn> c_wraith: But making those handle dense cases is tricky
2022-01-21 15:04:52 +0100 <[exa]> dimensionality is ~5, ~20, or greater?
2022-01-21 15:05:15 +0100 <merijn> [exa]: Probably ~5 and only (hyper)cuboids, so axis aligned, yeah
2022-01-21 15:05:33 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it)
2022-01-21 15:05:34 +0100 <[exa]> then some kind of R-trees should work
2022-01-21 15:05:49 +0100 <c_wraith> Heck, with that much structure you could just do a binary search on each axis
2022-01-21 15:05:51 +0100 <merijn> c_wraith: Effectively BVH are trees where every node is marked with the bounding volume of its sub-nodes
2022-01-21 15:06:02 +0100 <merijn> c_wraith: I'm not sure you can?
2022-01-21 15:06:07 +0100 <merijn> c_wraith: How would that work?
2022-01-21 15:06:13 +0100 <[exa]> merijn: how many volumes do you have there btw?
2022-01-21 15:06:43 +0100 <merijn> [exa]: Common case: Very little (tens-hundreds), theoretical worst case: millions
2022-01-21 15:07:15 +0100 <merijn> c_wraith: What would you binary search on?
2022-01-21 15:07:16 +0100 <[exa]> I'd throw it to a GPU and just bruteforce it
2022-01-21 15:07:24 +0100 <[exa]> even for millions it's like in 1 click
2022-01-21 15:07:44 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41)
2022-01-21 15:08:34 +0100 <c_wraith> I mean, it's not maximally efficient, but it's simple. search over a sorted list of bounds in each dimension, intersect the results. I suppose that could be bad if the active set is changing a lot.
2022-01-21 15:09:01 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2022-01-21 15:09:03 +0100 <[exa]> in the other case I'd go with some variant of R tree constructed along simple splitting planes
2022-01-21 15:09:14 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Quit: ChaiTRex)
2022-01-21 15:09:49 +0100 <[exa]> the chances you hit a good binary split in a few tries is quite high usually
2022-01-21 15:09:54 +0100 <[exa]> *are
2022-01-21 15:10:04 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2022-01-21 15:10:09 +0100 <[exa]> unless your data is pathological, at which point it is sometimes better to just subdivide the data
2022-01-21 15:11:17 +0100romesrf(~romes@44.190.189.46.rev.vodafone.pt) (Quit: WeeChat 3.4)
2022-01-21 15:14:09 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2022-01-21 15:15:53 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 15:17:03 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2022-01-21 15:20:41 +0100xkuru(~xkuru@user/xkuru)
2022-01-21 15:21:18 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2022-01-21 15:28:17 +0100qrpnxz(abc4f95c31@user/qrpnxz) (Quit: Gateway shutdown)
2022-01-21 15:28:43 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 15:30:15 +0100max22-(~maxime@2a01cb088335980025090258985cbdb2.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-21 15:32:16 +0100justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.3)
2022-01-21 15:32:45 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2022-01-21 15:32:45 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2022-01-21 15:32:47 +0100mcgroin(~mcgroin@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2022-01-21 15:32:48 +0100allbery_bgeekosaur
2022-01-21 15:38:05 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao)
2022-01-21 15:41:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 15:41:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 15:41:59 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 15:42:10 +0100phma(phma@2001:5b0:211b:b1e8:ef4c:8052:a169:f66a) (Read error: Connection reset by peer)
2022-01-21 15:42:11 +0100 <merijn> [exa]: R-trees seem to, effectively, be trickier versions of BVHs?
2022-01-21 15:42:29 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4)
2022-01-21 15:43:05 +0100phma(phma@2001:5b0:211f:5068:5bee:1f6d:8374:247d)
2022-01-21 15:43:22 +0100 <merijn> [exa]: Additionally I also don't know how to construct R-trees, so that just turns my "what's a good introduction to how to construct a BVH" to "what's a good introduction to constructing an R-tree?"
2022-01-21 15:44:08 +0100o-90(~o-90@gateway/tor-sasl/o-90)
2022-01-21 15:44:49 +0100 <merijn> oh, actually, turns out R-trees are a subset of BVHs :p
2022-01-21 15:44:57 +0100 <[exa]> R trees are BVHs that allow overlap
2022-01-21 15:45:14 +0100 <[exa]> or maybe the other way, yeah
2022-01-21 15:46:05 +0100 <[exa]> re construction method: you'll get a pretty good R tree by just trying random separating planes at each step, and making 1 child from "everything that's wholly on side" and the second child from "everything that's left"
2022-01-21 15:46:11 +0100max22-(~maxime@2a01cb08833598001513a4ce4dc1d3d2.ipv6.abo.wanadoo.fr)
2022-01-21 15:46:24 +0100 <[exa]> I'd suggest trying like 5-10 random choices and pick the one that separates best
2022-01-21 15:46:42 +0100 <[exa]> random trees are really good in average case
2022-01-21 15:49:34 +0100rusrushal13(~rusrushal@2409:4056:e03:14be:158d:b825:79a6:6bc)
2022-01-21 15:53:31 +0100o-90(~o-90@gateway/tor-sasl/o-90) (Remote host closed the connection)
2022-01-21 15:53:36 +0100SummerSonw(~The_viole@203.77.49.232) (Remote host closed the connection)
2022-01-21 15:53:59 +0100SummerSonw(~The_viole@203.77.49.232)
2022-01-21 15:55:18 +0100Pickchea(~private@user/pickchea)
2022-01-21 15:55:19 +0100red-snail(~snail@static.151.210.203.116.clients.your-server.de) (Quit: ZNC 1.8.2 - https://znc.in)
2022-01-21 15:55:28 +0100euandreh(~euandreh@2804:14c:33:9fe5:9d95:c71:11e4:3e0f) (Quit: WeeChat 3.3)
2022-01-21 15:55:41 +0100red-snail(~snail@static.151.210.203.116.clients.your-server.de)
2022-01-21 15:56:41 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2022-01-21 15:56:57 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41) (Ping timeout: 240 seconds)
2022-01-21 15:56:59 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-21 15:57:14 +0100burnside_(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 15:57:15 +0100euandreh(~euandreh@2804:14c:33:9fe5:c17:d8ca:f795:73f0)
2022-01-21 16:00:39 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 256 seconds)
2022-01-21 16:01:13 +0100Pickchea(~private@user/pickchea) (Ping timeout: 256 seconds)
2022-01-21 16:02:50 +0100Pickchea(~private@user/pickchea)
2022-01-21 16:07:55 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2022-01-21 16:08:13 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-21 16:08:48 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-21 16:10:00 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480:1b88:50f:dae0:9293)
2022-01-21 16:10:14 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-21 16:10:57 +0100xff0x(~xff0x@2001:1a81:52b8:8500:6c95:ecd6:fb54:75ad) (Ping timeout: 240 seconds)
2022-01-21 16:11:06 +0100slac94902(~slack1256@186.11.31.133)
2022-01-21 16:11:32 +0100 <byorgey> geekosaur: ah, sad (re: matrix builder)
2022-01-21 16:13:22 +0100slack1256(~slack1256@191.125.227.213) (Ping timeout: 250 seconds)
2022-01-21 16:17:39 +0100rusrushal13(~rusrushal@2409:4056:e03:14be:158d:b825:79a6:6bc) (Ping timeout: 256 seconds)
2022-01-21 16:24:36 +0100Sgeo(~Sgeo@user/sgeo)
2022-01-21 16:26:29 +0100rusrushal13(~rusrushal@2409:4056:e03:14be:158d:b825:79a6:6bc)
2022-01-21 16:26:45 +0100kaph(~kaph@net-2-47-208-144.cust.vodafonedsl.it)
2022-01-21 16:28:14 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2022-01-21 16:28:58 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-21 16:31:34 +0100ksqsf(~user@2001:da8:d800:611:7915:1763:796:9db6) (Ping timeout: 250 seconds)
2022-01-21 16:35:24 +0100SummerSonw(~The_viole@203.77.49.232) (Ping timeout: 256 seconds)
2022-01-21 16:36:55 +0100rusrushal13(~rusrushal@2409:4056:e03:14be:158d:b825:79a6:6bc) (Ping timeout: 256 seconds)
2022-01-21 16:37:25 +0100incertia(~incertia@207.98.176.56) (Read error: Connection reset by peer)
2022-01-21 16:37:32 +0100vysn(~vysn@user/vysn) (Ping timeout: 240 seconds)
2022-01-21 16:37:43 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 16:37:43 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 16:37:43 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 16:37:57 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480:1b88:50f:dae0:9293) (Ping timeout: 240 seconds)
2022-01-21 16:42:16 +0100incertia(~incertia@24.42.246.251)
2022-01-21 16:42:35 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 16:42:48 +0100shapr(~user@2601:7c0:c37c:46d0:25fd:6854:a2a7:2f62)
2022-01-21 16:42:59 +0100burnside_(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Remote host closed the connection)
2022-01-21 16:43:33 +0100xff0x(~xff0x@2001:1a81:52b8:8500:6c95:ecd6:fb54:75ad)
2022-01-21 16:43:46 +0100slack1256(~slack1256@191.126.227.213)
2022-01-21 16:44:15 +0100alp(~alp@user/alp) (Ping timeout: 268 seconds)
2022-01-21 16:45:50 +0100ksqsf(~user@2001:da8:d800:611:7915:1763:796:9db6)
2022-01-21 16:45:59 +0100slac94902(~slack1256@186.11.31.133) (Ping timeout: 256 seconds)
2022-01-21 16:48:49 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 16:50:32 +0100ksqsf(~user@2001:da8:d800:611:7915:1763:796:9db6) (Ping timeout: 240 seconds)
2022-01-21 16:53:52 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 16:57:11 +0100ksqsf(~user@2001:da8:d800:611:d47b:4206:e65:5027)
2022-01-21 16:57:57 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Ping timeout: 240 seconds)
2022-01-21 16:57:57 +0100Guest5261(~Guest52@80-100-97-100.ip.xs4all.nl) (Ping timeout: 240 seconds)
2022-01-21 17:01:54 +0100ksqsf(~user@2001:da8:d800:611:d47b:4206:e65:5027) (Ping timeout: 250 seconds)
2022-01-21 17:05:10 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2022-01-21 17:05:12 +0100 <hololeap> I just had to patch someone's library for ghc-9.0.2, where this first line gives an error, but this second line works fine. what is the explaination for this?
2022-01-21 17:05:36 +0100 <hololeap> applyMap = view ∘ mapIso
2022-01-21 17:05:42 +0100 <hololeap> applyMap m = view $ mapIso m
2022-01-21 17:05:54 +0100dyeplexer(~dyeplexer@user/dyeplexer)
2022-01-21 17:06:10 +0100 <[exa]> monomorphism restriction? <- blind shot
2022-01-21 17:06:25 +0100 <[exa]> the definition of ∘ is the same as of . right?
2022-01-21 17:06:36 +0100 <hololeap> yes, AFAIK
2022-01-21 17:06:47 +0100 <[exa]> does the function have an explicit type signature?
2022-01-21 17:06:49 +0100 <ski> is there any type signature for `applyMap' ?
2022-01-21 17:06:55 +0100 <[exa]> (if not, try the first variant with the type signature)
2022-01-21 17:06:56 +0100skilow fours [exa]
2022-01-21 17:07:12 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2022-01-21 17:07:19 +0100 <geekosaur> simplified subsumption?
2022-01-21 17:07:24 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2022-01-21 17:07:26 +0100 <hololeap> https://github.com/mvoidex/text-region/blob/master/src/Data/Text/Region.hs#L81
2022-01-21 17:07:41 +0100 <maerwald> https://downloads.haskell.org/~ghc/9.0.1/docs/html/users_guide/exts/rank_polymorphism.html#simple-…
2022-01-21 17:07:50 +0100 <geekosaur> see the 9.0.1 release notes and https://downloads.haskell.org/ghc/9.0.2/docs/html/users_guide/exts/rank_polymorphism.html#simple-s…
2022-01-21 17:07:51 +0100 <maerwald> geekosaur: what I thought
2022-01-21 17:08:04 +0100 <ski> are any of `Map' or `Region' type synonyms ?
2022-01-21 17:08:23 +0100 <hololeap> Couldn't match type: forall (p :: * -> * -> *) (f :: * -> *). (Profunctor p, Functor f) => p Region (f Region) -> p Region (f Region) with: (Region -> Const Region Region) -> Region -> Const Region Region
2022-01-21 17:08:45 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 17:08:45 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 17:08:45 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 17:09:40 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:ba7b:1b5c:238c:4447) (Quit: WeeChat 2.8)
2022-01-21 17:10:15 +0100 <hololeap> Expected: Map -> Getting Region Region Region Actual: Map -> Iso' Region Region
2022-01-21 17:12:47 +0100 <[exa]> is it just me or is there a dangling ) in the 9.0.1 release notes, in the signature of `g4` ?
2022-01-21 17:13:03 +0100 <[exa]> or missing (
2022-01-21 17:13:05 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-21 17:13:11 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 17:13:19 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 17:13:27 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2022-01-21 17:13:49 +0100 <ski> [exa] : i think the trailing `) -> Bool' should be removed
2022-01-21 17:14:22 +0100 <[exa]> very true
2022-01-21 17:15:01 +0100ksqsf(~user@222.195.66.54)
2022-01-21 17:15:03 +0100 <[exa]> also "arbitrary-aank" types below
2022-01-21 17:15:34 +0100 <[exa]> where do I send a patch?
2022-01-21 17:16:20 +0100 <maerwald> ghc repo? :D
2022-01-21 17:19:30 +0100myShoggoth(~myShoggot@97-120-67-120.ptld.qwest.net)
2022-01-21 17:19:38 +0100 <[exa]> `grep aank ghc -r` -> nothing ;_;
2022-01-21 17:19:47 +0100 <[exa]> maybe it's fixed in master now
2022-01-21 17:19:59 +0100ksqsf(~user@222.195.66.54) (Ping timeout: 256 seconds)
2022-01-21 17:19:59 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 17:20:41 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 17:21:03 +0100 <maerwald> oh, new alex release, causing new build failures with c2hs/language-c
2022-01-21 17:21:06 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2022-01-21 17:22:13 +0100 <maerwald> https://github.com/simonmar/alex/issues/197
2022-01-21 17:22:28 +0100ksqsf(~user@2001:da8:d800:611:7c44:28ce:f32f:226)
2022-01-21 17:22:52 +0100Guest|28(~Guest|28@136.228.217.112)
2022-01-21 17:23:36 +0100Guest|28(~Guest|28@136.228.217.112) (Client Quit)
2022-01-21 17:23:52 +0100 <maerwald> I'm starting to believe in stackage snapshots
2022-01-21 17:24:37 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 17:24:38 +0100fef(~thedawn@user/thedawn) (Quit: Leaving)
2022-01-21 17:24:44 +0100 <maerwald> even critical core packages can't maintain PVP expectations
2022-01-21 17:24:49 +0100lagash_(lagash@lagash.shelltalk.net) (Quit: ZNC - https://znc.in)
2022-01-21 17:25:05 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 256 seconds)
2022-01-21 17:25:16 +0100lagash(lagash@lagash.shelltalk.net)
2022-01-21 17:27:02 +0100ksqsf(~user@2001:da8:d800:611:7c44:28ce:f32f:226) (Ping timeout: 240 seconds)
2022-01-21 17:31:30 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 256 seconds)
2022-01-21 17:33:26 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2022-01-21 17:34:30 +0100Jing(~hedgehog@240e:390:7c53:a7e1:81fd:e333:1e93:e27e) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2022-01-21 17:35:02 +0100CiaoSen(~Jura@p200300c95737a2002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2022-01-21 17:36:04 +0100shriekingnoise(~shrieking@201.231.16.156)
2022-01-21 17:36:54 +0100justJustachejustache
2022-01-21 17:38:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 17:38:59 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 17:38:59 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 17:39:36 +0100ksqsf(~user@2001:da8:d800:611:2156:d87c:1289:bb62)
2022-01-21 17:40:00 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 17:43:33 +0100Akiva(~Akiva@user/Akiva)
2022-01-21 17:43:47 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 17:43:58 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 17:44:48 +0100ksqsf(~user@2001:da8:d800:611:2156:d87c:1289:bb62) (Ping timeout: 250 seconds)
2022-01-21 17:45:46 +0100alp(~alp@user/alp)
2022-01-21 17:46:42 +0100jakalx(~jakalx@base.jakalx.net)
2022-01-21 17:48:19 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2022-01-21 17:48:29 +0100eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net)
2022-01-21 17:48:30 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2022-01-21 17:52:22 +0100 <EvanR> if there's a function emb :: A -> B and for any function f on A's a function h f :: B -> B such that g f (emb x) = emb (f x)... what is that, or is that somehow just automatic and obvious
2022-01-21 17:52:36 +0100vpan(~0@212.117.1.172) (Quit: Leaving.)
2022-01-21 17:52:42 +0100 <EvanR> and does this make A and subtype of B or vice versa
2022-01-21 17:52:49 +0100 <EvanR> A a*
2022-01-21 17:53:10 +0100 <EvanR> ... g should be h
2022-01-21 17:53:14 +0100 <EvanR> I got mixed up
2022-01-21 17:53:33 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2022-01-21 17:55:01 +0100 <ski> hm, reminds me of dynamical systems
2022-01-21 17:55:23 +0100 <EvanR> https://paste.tomsmeding.com/CqElZb7k
2022-01-21 17:55:50 +0100 <ski> yep, i just conceptualized that commuting diagram
2022-01-21 17:56:02 +0100zer0bitz(~zer0bitz@2001:2003:f444:a000:295b:27c3:87b1:2b8f) (Ping timeout: 240 seconds)
2022-01-21 17:57:44 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 17:57:46 +0100ksqsf(~user@222.195.66.54)
2022-01-21 17:58:53 +0100eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2022-01-21 17:59:36 +0100lbseale(~ep1ctetus@user/ep1ctetus)
2022-01-21 18:00:03 +0100 <ski> hm. `emb' induces a partition on `A' (two elements are in the same partition if they map to the same element of `B'). the diagram then claims that `f' must map all elements in a part into a common part, and `h f' must map the `b' of the first part to the `b' of the second part
2022-01-21 18:00:24 +0100remedan(~remedan@octo.cafe) (Ping timeout: 256 seconds)
2022-01-21 18:01:09 +0100 <ski> also, if there's any element of `b' that's not in the image of `emb', then `h f' is free to choose where to send it
2022-01-21 18:01:55 +0100incertia(~incertia@24.42.246.251) (Ping timeout: 256 seconds)
2022-01-21 18:01:59 +0100 <EvanR> this h is kind of tricky then
2022-01-21 18:02:29 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 256 seconds)
2022-01-21 18:02:50 +0100 <EvanR> it has to obey a law in some case (emb is looking at you) and not others
2022-01-21 18:03:04 +0100 <ski> hm. so what if we pick an `f' that does not respect the partition induced by `emb' ?
2022-01-21 18:03:14 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 256 seconds)
2022-01-21 18:03:33 +0100 <ski> i guess we're talking about a situation with an `A', an `B', and an `emb', where there is no such `f'
2022-01-21 18:04:09 +0100 <EvanR> "any function f on A's" might be the tricky part
2022-01-21 18:04:18 +0100 <ski> hm, which would imply that `emb' is injective, so that the partition is the discrete/trivial one
2022-01-21 18:04:22 +0100incertia(~incertia@207.98.242.204)
2022-01-21 18:04:43 +0100 <ski> hm
2022-01-21 18:05:25 +0100remedan(~remedan@octo.cafe)
2022-01-21 18:05:33 +0100 <ski> yea, if every element of `A' is in its own part / equivalence class, then there's no restriction on differering elements (in the same part) having to be mapped into a common part
2022-01-21 18:05:34 +0100 <EvanR> h is kind of like fmap
2022-01-21 18:05:43 +0100 <EvanR> isn't it
2022-01-21 18:06:14 +0100 <ski> so, unless i'm missing something, it seems that like one would be able to prove that `emb' must be injective, for this condition to hold
2022-01-21 18:06:36 +0100 <EvanR> i didn't follow that, what condition
2022-01-21 18:06:37 +0100 <ski> (which i guess then justifies using the name `emb', as in "embedding", for it)
2022-01-21 18:07:31 +0100 <ski> forall f :: A -> A. exists g :: B -> B. g . emb = emb . f
2022-01-21 18:07:43 +0100 <ski> (the condition you started with)
2022-01-21 18:07:57 +0100 <EvanR> ah
2022-01-21 18:08:36 +0100 <EvanR> gnarly
2022-01-21 18:09:47 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 18:09:58 +0100 <EvanR> what's the meaning of these g's that do whatever they want with B not in the image of emb
2022-01-21 18:11:21 +0100 <EvanR> also, if emb is necessarily injective, then I guess that makes A and subset / subtype? of B
2022-01-21 18:11:32 +0100 <EvanR> ... A a
2022-01-21 18:11:41 +0100 <ski> yes
2022-01-21 18:11:58 +0100 <ski> (trying to think of how one might be able to prove injectivity)
2022-01-21 18:12:46 +0100xb0o2(~xb0o2@user/xb0o2) (Quit: Client closed)
2022-01-21 18:13:56 +0100 <EvanR> well if B = (), it seems hard to be injective xD
2022-01-21 18:14:16 +0100 <ski> heh, then `A' is a subsingleton, yea
2022-01-21 18:14:21 +0100 <ski> (aka a proposition)
2022-01-21 18:14:42 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2022-01-21 18:14:59 +0100 <EvanR> then g = id and works
2022-01-21 18:16:04 +0100xb0o2(~xb0o2@user/xb0o2)
2022-01-21 18:16:38 +0100 <EvanR> hmm? A could be Int, f any Int function, and B = () and g = id?
2022-01-21 18:16:55 +0100 <EvanR> what subsingleton u talkin about
2022-01-21 18:17:02 +0100Major_Biscuit(~MajorBisc@c-001-024-001.client.tudelft.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 18:17:54 +0100darchitect(~darchitec@2a00:23c6:3584:df00:7dec:bf13:8fa:748c)
2022-01-21 18:17:58 +0100 <darchitect> #haskell
2022-01-21 18:17:59 +0100 <EvanR> there's at most 1 partition, yeah
2022-01-21 18:18:08 +0100 <darchitect> ?src ($)
2022-01-21 18:18:08 +0100 <lambdabot> f $ x = f x
2022-01-21 18:18:18 +0100 <ski> oh, right. with the indiscrete/cotrivial partition (everything in the same part / equivalence class), there's also no restriction
2022-01-21 18:18:27 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 18:18:28 +0100darchitect(~darchitec@2a00:23c6:3584:df00:7dec:bf13:8fa:748c) (Client Quit)
2022-01-21 18:18:38 +0100skiblinks
2022-01-21 18:18:45 +0100geekosaurwonders what that was about
2022-01-21 18:19:05 +0100 <EvanR> apparently you can use ? to invoke lambdabot
2022-01-21 18:19:18 +0100 <geekosaur> yep
2022-01-21 18:19:25 +0100 <geekosaur> some people do so habitually
2022-01-21 18:19:29 +0100 <maerwald> ??
2022-01-21 18:19:31 +0100 <ski> EvanR : if `B' is `()', and `emb' injective, then `A' is a subsingleton (subtype of unit)
2022-01-21 18:19:37 +0100ksqsf(~user@222.195.66.54) (Ping timeout: 240 seconds)
2022-01-21 18:19:49 +0100 <maerwald> ?(?)
2022-01-21 18:19:55 +0100 <EvanR> just to be clear, we can't prove emb is an injection in general right
2022-01-21 18:20:08 +0100 <geekosaur> @(?)
2022-01-21 18:20:11 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 18:20:18 +0100 <ski> maybeit requires axiom of choice, or proof-by-contradiction, or something ..
2022-01-21 18:20:22 +0100 <geekosaur> apparently lb ignores some kinds of noise
2022-01-21 18:20:32 +0100 <ski> (or maybe i was missing something in my information consideration above)
2022-01-21 18:20:34 +0100 <EvanR> maybe I missed another condition you brought up
2022-01-21 18:20:40 +0100 <geekosaur> ?info blah
2022-01-21 18:20:40 +0100 <lambdabot> blah
2022-01-21 18:20:45 +0100 <maerwald> geekosaur: makes sense, it's been ignoring me for some time xD
2022-01-21 18:20:56 +0100 <ski> i'm not immediately seeing how you could prove it, constructively, anyway
2022-01-21 18:20:59 +0100 <monochrom> ?info is auto-corrected to ?undo
2022-01-21 18:21:05 +0100 <EvanR> didn't I just disprove it?
2022-01-21 18:21:08 +0100 <EvanR> is what I'm saying
2022-01-21 18:21:11 +0100 <geekosaur> yes, I know
2022-01-21 18:21:33 +0100 <ski> EvanR : oh, ah. sorry, yes
2022-01-21 18:21:48 +0100 <ski> hm
2022-01-21 18:21:57 +0100 <geekosaur> (I seriously considered adding a line to lb to output when it was doing that, back when I was using lb as a channel logger)
2022-01-21 18:22:50 +0100 <EvanR> since it seems functor like, you'd expect some "embeddings" to cause loss of info
2022-01-21 18:23:02 +0100 <EvanR> collision
2022-01-21 18:23:19 +0100LukeHoersten(~LukeHoers@user/lukehoersten)
2022-01-21 18:23:29 +0100 <EvanR> I guess embedding is supposed to imply that doesn't happen
2022-01-21 18:24:17 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 240 seconds)
2022-01-21 18:24:38 +0100 <ski> hm, so if we have at least two parts, at least one of them containing at least two elements (iow `emb' being non-injective), then there's an `f' that doesn't respect the partition
2022-01-21 18:24:53 +0100 <EvanR> it's a functor between two categories of endomorphisms
2022-01-21 18:25:07 +0100 <ski> so, i guess, either `B' is subsingleton, or `emb' is injective
2022-01-21 18:25:28 +0100 <ski> (that's presumably a multiplicative / non-constructive disjunction)
2022-01-21 18:26:21 +0100 <EvanR> what does f respecting the partition mean
2022-01-21 18:26:22 +0100 <ski> how's it a functor ?
2022-01-21 18:26:52 +0100 <ski> EvanR : the aforementioned condition
2022-01-21 18:27:19 +0100 <EvanR> g . emb = emb . f
2022-01-21 18:27:23 +0100 <ski> (if two elements are in the same part, then `f' must map them into a common part)
2022-01-21 18:27:32 +0100 <EvanR> oh
2022-01-21 18:27:54 +0100 <EvanR> yeah so that's what you've been working with the whole time, I see how that is easily not the case
2022-01-21 18:28:13 +0100econo(uid147250@user/econo)
2022-01-21 18:29:47 +0100 <ski> emb (f x) = g (emb x) ={ `x',`y' in same part }= g (emb y) = emb (f y)
2022-01-21 18:29:54 +0100 <ski> ergo, `f x',`f y' in same part
2022-01-21 18:32:20 +0100ksqsf(~user@222.195.66.54)
2022-01-21 18:32:57 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2022-01-21 18:33:36 +0100 <EvanR> oh, that's cool. So f has to respect the partition
2022-01-21 18:33:56 +0100 <EvanR> is that right
2022-01-21 18:34:20 +0100 <EvanR> I take back my functor thing, I was mixed up
2022-01-21 18:34:50 +0100 <ski> yes, that's what `g . emb = emb . f' says (and `g' is the part mapping)
2022-01-21 18:34:50 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2022-01-21 18:35:40 +0100 <EvanR> so the existence of B, emb, and these g's induces dynamical partitions on A...
2022-01-21 18:35:45 +0100 <EvanR> weird
2022-01-21 18:35:59 +0100 <ski> `emb' induces the partition
2022-01-21 18:36:14 +0100 <EvanR> by itself?
2022-01-21 18:36:28 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 18:36:44 +0100 <EvanR> the dynamical partitioning doesn't know about emb
2022-01-21 18:36:46 +0100 <ski> `x' and `y' are defined to be equivalent (in the same part) iff `emb x = emb y'
2022-01-21 18:36:53 +0100 <EvanR> the f's
2022-01-21 18:37:04 +0100 <ski> and the insistance of there being a `g' for every `f' seems to imply that either `B' is subsingleton, or `emb' is injective
2022-01-21 18:37:06 +0100ksqsf(~user@222.195.66.54) (Ping timeout: 268 seconds)
2022-01-21 18:37:56 +0100 <EvanR> I'm trippin, any f :: A -> A results in some kind of dynamic partition, even if it's trivial
2022-01-21 18:38:02 +0100 <EvanR> orbits
2022-01-21 18:38:18 +0100 <ski> any `f' describes a dynamical system on `A'
2022-01-21 18:38:32 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net) (Ping timeout: 240 seconds)
2022-01-21 18:38:50 +0100 <EvanR> f automatically respects those
2022-01-21 18:38:59 +0100 <ski> and you're claiming that for any dynamical system on `A', there is a dynamical system on `B', with `emb' being the dynamical system morphism between them
2022-01-21 18:39:15 +0100 <ski> (s/you/your condition/)
2022-01-21 18:40:37 +0100 <ski> so, we're talking about objects `A',`B' and morphism `emb' such that any dynamical system on `A' induces one on `B', with `emb' a morphism between them
2022-01-21 18:41:09 +0100 <EvanR> is the g unique
2022-01-21 18:41:24 +0100 <EvanR> guess not since you could reverse whatever the g system is
2022-01-21 18:41:41 +0100 <EvanR> or shift it over one
2022-01-21 18:41:58 +0100 <ski> you had no such condition. if `emb' is not surjective, then there's leeway/choice in where `g' sends "unassigned parts"
2022-01-21 18:42:08 +0100 <EvanR> oh yeah that
2022-01-21 18:42:42 +0100 <EvanR> dynamical system morphism, got it
2022-01-21 18:42:53 +0100 <ski> (although if we're talking about some other category than `Set', considering dynamical systems over that, we could probably have a unique `g' even if `emb' is not epi)
2022-01-21 18:44:37 +0100 <ski> ("f automatically respects those" -- which ?)
2022-01-21 18:44:44 +0100 <EvanR> it's own orbits
2022-01-21 18:44:52 +0100 <EvanR> partitions
2022-01-21 18:45:01 +0100 <ski> yea, `f . f = f . f'
2022-01-21 18:45:33 +0100 <ski> well, the orbits aren't the parts induced by `emb'
2022-01-21 18:45:34 +0100 <EvanR> um, interesting xD
2022-01-21 18:45:40 +0100 <EvanR> no, the orbits are just there
2022-01-21 18:46:33 +0100 <ski> anyway, yes, `f' is a morphism from the dynamical system `(A,f)' to itself
2022-01-21 18:47:08 +0100 <ski> (which `f . f = f . f' verifies)
2022-01-21 18:47:42 +0100 <EvanR> and if any two morphisms compose, it's a category
2022-01-21 18:47:58 +0100 <EvanR> with compatible types
2022-01-21 18:48:04 +0100 <ski> well, i'd not call them morphisms, otherwise :p
2022-01-21 18:49:21 +0100 <EvanR> does any morphism have 1 to 1 correspondence between orbits
2022-01-21 18:49:25 +0100 <tomjaguarpaw> Does DerivingVia only make sense for things of kind Type?
2022-01-21 18:49:31 +0100zincy_(~zincy@2a00:23c8:970c:4801:f0bc:c4cb:1665:1c67)
2022-01-21 18:49:55 +0100 <tomjaguarpaw> Could I, for example, implement the MTL instance boilerplate using DerivingVia?
2022-01-21 18:50:16 +0100 <tomjaguarpaw> The instances of are things of kind (Type -> Type) -> Type -> Type which makes me think not
2022-01-21 18:50:31 +0100 <tomjaguarpaw> There wouldn't be a suitable Coercible
2022-01-21 18:50:51 +0100 <awpr> oddly enough Coercible does exist for partially applied type constructors
2022-01-21 18:51:40 +0100 <tomjaguarpaw> Aha, that sounds useful
2022-01-21 18:51:40 +0100 <ski> forall DA : DynSys | U DA = A. exists DB : DynSys | U DB = B. exists demb : DA >---> DB. U demb = emb
2022-01-21 18:51:48 +0100 <ski> something like that, i guess .. hmm
2022-01-21 18:51:57 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 18:52:05 +0100 <ski> EvanR : hm, not sure what you mean by that ?
2022-01-21 18:52:11 +0100 <awpr> > let x :: Coercible m n => m a -> n a; x = coerce in x @Maybe @Maybe
2022-01-21 18:52:12 +0100 <lambdabot> <hint>:1:53: error:
2022-01-21 18:52:12 +0100 <lambdabot> Pattern syntax in expression context: x@Maybe
2022-01-21 18:52:12 +0100 <lambdabot> Did you mean to enable TypeApplications?
2022-01-21 18:52:21 +0100 <awpr> % let x :: Coercible m n => m a -> n a; x = coerce in x @Maybe @Maybe
2022-01-21 18:52:21 +0100 <yahb> awpr: ; <interactive>:18:1: error:; * No instance for (Show (Maybe a0 -> Maybe a0)) arising from a use of `print'; (maybe you haven't applied a function to enough arguments?); * In a stmt of an interactive GHCi command: print it
2022-01-21 18:52:32 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 18:53:37 +0100 <ski> % let x :: Coercible m n => m a -> n a; x = coerce in x @Maybe @Maybe @Void Nothing
2022-01-21 18:53:37 +0100 <yahb> ski: Nothing
2022-01-21 18:54:07 +0100alexd(~nineonine@50.216.62.2)
2022-01-21 18:54:33 +0100 <awpr> IIRC `Coercible (m :: k -> Type) n` means for all equal type arguments (note: not all coercible arguments), GHC will use it to solve `Coercible (m a) (n a)`. but there's another thing you need if that's to be useful: the instances need to exist, and I don't know off the top of my head whether they do
2022-01-21 18:56:02 +0100 <awpr> actually this is probably an unnecessary diversion: DerivingVia is used routinely for Monad instances, where the kind is `Type -> Type`. is this case actually any different from that?
2022-01-21 18:56:36 +0100alMalsamo(~alMalsamo@gateway/tor-sasl/almalsamo) (Ping timeout: 276 seconds)
2022-01-21 18:59:28 +0100 <EvanR> ski, the source and target dynamical system have the same number of orbits, i.e. their set of orbits are in a 1 to 1 correspondence?
2022-01-21 18:59:53 +0100vicfred(~vicfred@user/vicfred)
2022-01-21 19:00:49 +0100 <ski> clearly you can map a DS consisting of two loops, to one consisting of just one (the length of which must then be a common divisor of the lengths of the previous ones)
2022-01-21 19:00:50 +0100 <EvanR> the morphism doesn't "split" orbits into suborbits, or doe sit
2022-01-21 19:01:18 +0100 <EvanR> wha
2022-01-21 19:01:34 +0100 <ski> (that's a non-injective morphism, obviously)
2022-01-21 19:02:27 +0100 <EvanR> how does the larger loop have a length that is a common divisor of two smaller loops
2022-01-21 19:02:35 +0100 <ski> if you think of the endofunction as (discrete) time. then if you take one time step, and then map over to the other system, that must be the same as mapping over to the other system, then taking a time step there
2022-01-21 19:02:51 +0100 <EvanR> yes
2022-01-21 19:02:55 +0100ubert1(~Thunderbi@p200300ecdf09943ef05cebfd8a506150.dip0.t-ipconnect.de) (Remote host closed the connection)
2022-01-21 19:03:30 +0100deadmarshal(~deadmarsh@95.38.113.215)
2022-01-21 19:03:31 +0100 <ski> the second system "simulates" the first, there's an "image" of the first, inside the second. this image might be non-singular, might conflate/coalesce different states of the former system, in case the morphism was non-injective
2022-01-21 19:03:37 +0100Henson(~kvirc@107-179-133-201.cpe.teksavvy.com) (Ping timeout: 240 seconds)
2022-01-21 19:03:40 +0100CiaoSen(~Jura@p200300c95737a2002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2022-01-21 19:04:10 +0100 <ski> larger loop ?
2022-01-21 19:04:23 +0100 <EvanR> oh now I see
2022-01-21 19:04:35 +0100 <EvanR> two big loops coalesce into 1 smaller loop
2022-01-21 19:04:40 +0100 <EvanR> tricky
2022-01-21 19:04:46 +0100 <ski> if you have a system `C_6 + C_10' (a six-loop and a ten-loop), you can map that to a `C_2' (two-loop)
2022-01-21 19:05:08 +0100 <EvanR> so the number of orbits stays the same or decreases
2022-01-21 19:05:47 +0100 <ski> (also, because the endofunctions are not required to be invertible, you can have "hairs"/"dendrites". so a dynamical system is a loop, with such "dendrites" (trees) hanging off it. (an infinite strand is considered a zero-loop))
2022-01-21 19:05:49 +0100 <EvanR> orbits are non-renewable
2022-01-21 19:06:55 +0100 <EvanR> almost forgot about not-loops
2022-01-21 19:07:07 +0100 <ski> well, could you clarify exactly what you mean by an orbit, here ? a maximal subset of elements where any two elements eventually end up the same, after time passing ?
2022-01-21 19:07:43 +0100 <EvanR> oh, and if f is not invertible, it could "fork when going back in time"
2022-01-21 19:07:44 +0100 <ski> or maybe you mean a map from `(Nat,succ)' ? (or `(Integer,succ)' ?)
2022-01-21 19:07:52 +0100 <ski> right, that's the tree branching
2022-01-21 19:08:10 +0100 <EvanR> I was thinking invertible
2022-01-21 19:08:23 +0100 <EvanR> an an orbit is a linear thing
2022-01-21 19:08:27 +0100 <EvanR> sequence
2022-01-21 19:08:42 +0100 <ski> extending in one direction ? or both ?
2022-01-21 19:09:18 +0100 <ski> mhm
2022-01-21 19:09:24 +0100LukeHoersten(~LukeHoers@user/lukehoersten) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2022-01-21 19:09:27 +0100 <EvanR> for loops might as well go 1 way, otherwise go back to the start
2022-01-21 19:09:38 +0100 <EvanR> oops there might not be a start
2022-01-21 19:09:51 +0100 <EvanR> both ways
2022-01-21 19:09:52 +0100 <ski> a map from `(Nat,succ)' is a sequence of elements, with a starting-point
2022-01-21 19:10:03 +0100 <ski> such maps are in bijection with the elements of the DS
2022-01-21 19:10:21 +0100 <ski> so `(Nat,succ)' plays the role of `()', in this category
2022-01-21 19:12:41 +0100 <ski> then there's also another DS, `(Nat,pred)' (where `pred 0 = 0'), which acts like a "truth-value object" (aka "subobject classifier"). any subobject (`(S,e)') of a DS `(A,f)' (iow, with a mono from `(S,e)' to `(A,f)) corresponds exactly to a map (the characteristic map) from `(A,f)' to `(Nat,pred)'
2022-01-21 19:13:30 +0100 <ski> oh, sorry, that should actually be `InfNat' (it also contains an infinity element)
2022-01-21 19:13:53 +0100 <ski> in `(Nat,pred)', `0' means "true", or "yes, the element is in the sub-DS". `1' means "false now, but true in one time step", and so on. then `inf' (or `fix succ') means "forever false"
2022-01-21 19:14:15 +0100 <ski> (`pred inf = inf', naturally)
2022-01-21 19:14:27 +0100incertia(~incertia@207.98.242.204) (Ping timeout: 256 seconds)
2022-01-21 19:14:36 +0100 <EvanR> cool
2022-01-21 19:14:54 +0100mc47(~mc47@xmonad/TheMC47)
2022-01-21 19:15:03 +0100 <ski> (well .. that's a bit aside. but it might be nice/fun to ponder)
2022-01-21 19:15:12 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 19:15:14 +0100w1gz_w1gz
2022-01-21 19:15:21 +0100incertia(~incertia@207.98.168.249)
2022-01-21 19:15:38 +0100 <EvanR> that ended up being a lot richer than my diagram led me to believe
2022-01-21 19:15:49 +0100TimWolla(~timwolla@2a01:4f8:150:6153:beef::6667) (Quit: Bye)
2022-01-21 19:17:05 +0100Akiva(~Akiva@user/Akiva)
2022-01-21 19:19:57 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-21 19:21:37 +0100TimWolla(~timwolla@2a01:4f8:150:6153:beef::6667)
2022-01-21 19:21:57 +0100 <ski> i'm still wondering if there's a nicer way to think about it, in terms of the underlying functor, or somesuch (like i attempted to formulate it, above)
2022-01-21 19:23:58 +0100max22-(~maxime@2a01cb08833598001513a4ce4dc1d3d2.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-21 19:25:15 +0100 <monochrom> I'm still in set theory. Here is what I found. The image of emb is a singleton, or emb is injective.
2022-01-21 19:25:36 +0100 <EvanR> really
2022-01-21 19:25:40 +0100 <ski> yea, i had s/singleton/subsingleton/
2022-01-21 19:26:02 +0100 <EvanR> why can't it be somewhere in between
2022-01-21 19:26:27 +0100 <ski> (but, if `B' is empty, then obviously `emb' is injective, so ..)
2022-01-21 19:26:27 +0100ksqsf(~user@222.195.66.54)
2022-01-21 19:26:53 +0100 <monochrom> I have a social commentary reading of that, too. The two Pareto points of evolution of society: everyone is part of the same hive mind, or everyone is independent >:)
2022-01-21 19:27:04 +0100 <ski> hehee :)
2022-01-21 19:27:10 +0100zmt00(~zmt00@user/zmt00)
2022-01-21 19:27:39 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 19:30:50 +0100dyeplexer(~dyeplexer@user/dyeplexer) (Remote host closed the connection)
2022-01-21 19:31:01 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2022-01-21 19:31:38 +0100ksqsf(~user@222.195.66.54) (Ping timeout: 256 seconds)
2022-01-21 19:32:42 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-21 19:34:14 +0100 <tomjaguarpaw> awpr: I got it to work it seems, thanks!
2022-01-21 19:35:02 +0100raym(~raym@user/raym) (Ping timeout: 256 seconds)
2022-01-21 19:35:59 +0100raym(~raym@user/raym)
2022-01-21 19:38:17 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 240 seconds)
2022-01-21 19:39:01 +0100Siv(~fuag1@174.127.249.180)
2022-01-21 19:39:31 +0100 <Siv> I'm having trouble getting a project to build on windows with it requiring unix, but unix not providing a library. I'm using stack
2022-01-21 19:39:53 +0100 <maerwald> Siv: that's pretty unfortunate
2022-01-21 19:40:24 +0100 <Siv> is there a work around or do i need to set up mingw32 or somethin' similar
2022-01-21 19:41:03 +0100 <polyphem> doesnt windows have linux subsystem now ?
2022-01-21 19:41:08 +0100 <geekosaur> there's a unix-compat library that will work for some things, but you may well need WSL or mingw
2022-01-21 19:41:12 +0100 <EvanR> somewhere someone is on unix cursing a project that requires windows to build
2022-01-21 19:41:15 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Remote host closed the connection)
2022-01-21 19:41:32 +0100jgeerds(~jgeerds@55d4a547.access.ecotel.net)
2022-01-21 19:41:32 +0100 <Siv> or a way to tell exactly what is causing the unix dependency? is unix a cross platform library that wraps posix functionality, it kinda looks like it
2022-01-21 19:41:34 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 19:41:43 +0100 <Siv> yeah i can try the compat layer, i think its network is isolated though which is a problem
2022-01-21 19:42:38 +0100 <maerwald> unix package doesn't work on windows
2022-01-21 19:43:01 +0100 <maerwald> so it's likely that you're trying to build a package that's not supported on windows
2022-01-21 19:43:59 +0100 <geekosaur> what package is this?
2022-01-21 19:44:01 +0100 <maerwald> mingw32 is already set up... stack does that automatically
2022-01-21 19:44:14 +0100 <Siv> is there a way to list what is getting pulled in by what to try to unpack what the conflict is? maybe i can hack in a replacement faster
2022-01-21 19:44:17 +0100 <geekosaur> yeh, mingw32 only goes so far
2022-01-21 19:44:24 +0100 <maerwald> Siv: yes... if you use cabal
2022-01-21 19:44:40 +0100 <Siv> oof, stack was a bad choice then
2022-01-21 19:44:41 +0100 <Siv> lol
2022-01-21 19:45:04 +0100 <maerwald> cabal puts resolution into dist-newstyle/cache/plan.json
2022-01-21 19:45:06 +0100 <Siv> its a project i did but i dev'd on unix and didn't think i was using anything super platform specific
2022-01-21 19:45:08 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net)
2022-01-21 19:45:13 +0100 <polyphem> windows too :)
2022-01-21 19:45:42 +0100 <maerwald> Siv: well, link to the project would help
2022-01-21 19:46:11 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Ping timeout: 256 seconds)
2022-01-21 19:46:59 +0100 <Siv> tis private but i'm just finidng i actually list unix in the dependencies. hmm i wish i remembered why, going to try removing it
2022-01-21 19:47:14 +0100 <geekosaur> try swapping with unix-compat first
2022-01-21 19:47:30 +0100 <maerwald> are you writing a HACK?
2022-01-21 19:47:31 +0100 <geekosaur> if you're lucky that will be good enough
2022-01-21 19:48:09 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 19:48:39 +0100 <Siv> no i just rolled this on unix. I was never planning on running it on a windows host. Turns out wsl and docker and exposing all that to the windows host is super non-trivial
2022-01-21 19:49:12 +0100Henson(~kvirc@107-179-133-201.cpe.teksavvy.com)
2022-01-21 19:49:39 +0100 <Siv> but maybe eating taking the time to figure that out is the way to go. Its kinda crazy to me that docker on windows has no real option to expose ports to the host
2022-01-21 19:49:47 +0100 <Siv> s/real/simple/
2022-01-21 19:50:02 +0100vysn(~vysn@user/vysn)
2022-01-21 19:50:20 +0100max22-(~maxime@2a01cb0883359800a734b5267d8e6eaf.ipv6.abo.wanadoo.fr)
2022-01-21 19:50:26 +0100 <Siv> but thats far from a stack problem. unix-compat didn't pan out
2022-01-21 19:51:02 +0100 <geekosaur> :(
2022-01-21 19:52:21 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 19:52:49 +0100themc47(~mc47@xmonad/TheMC47)
2022-01-21 19:52:52 +0100 <Siv> well, i GET to learn more about windows / wsl networking today :P
2022-01-21 19:53:12 +0100 <Siv> thanks for the suggestions of unix-compat and pointing out this is likely a dead end to try to hack around
2022-01-21 19:53:33 +0100mc47(~mc47@xmonad/TheMC47) (Ping timeout: 256 seconds)
2022-01-21 19:53:33 +0100themc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2022-01-21 19:54:00 +0100Henson(~kvirc@107-179-133-201.cpe.teksavvy.com) (Client Quit)
2022-01-21 19:54:29 +0100mc47(~mc47@xmonad/TheMC47)
2022-01-21 19:56:17 +0100ph88(~ph88@2a02:8109:9e00:71d0:e821:f261:3387:e512) (Quit: Leaving)
2022-01-21 19:56:37 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Ping timeout: 240 seconds)
2022-01-21 19:57:07 +0100ksqsf(~user@2001:da8:d800:611:9019:cb2c:2b8f:4e39)
2022-01-21 19:57:18 +0100tzh_(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2022-01-21 19:57:34 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Remote host closed the connection)
2022-01-21 20:00:55 +0100lechner(~lechner@debian/lechner)
2022-01-21 20:01:04 +0100 <maerwald> windows WSL2 works great
2022-01-21 20:01:44 +0100ksqsf(~user@2001:da8:d800:611:9019:cb2c:2b8f:4e39) (Ping timeout: 250 seconds)
2022-01-21 20:04:55 +0100johnw(~johnw@2607:f6f0:3004:1:c8b4:50ff:fef8:6bf0)
2022-01-21 20:05:32 +0100 <Siv> yeah, i'm reading up on it, if you have experience maybe you have some tips. I need to host a postgresql server and some web servers that need to be connected to by my windows host and others on my network. I can allow the ports needed through my firewall, route through my modem, and create a proxy to the wsl2 vm
2022-01-21 20:06:01 +0100 <maerwald> sounds like you're writing a HACK
2022-01-21 20:06:06 +0100 <Siv> last time i tried running a postgresql db from wsl2 i was told to sod off for some reason that I cant remember so I'm doing a dry run of that
2022-01-21 20:06:16 +0100 <maerwald> but networking is one of the few things that doesn't work that well in WSL2, lol
2022-01-21 20:06:31 +0100alp(~alp@user/alp) (Ping timeout: 268 seconds)
2022-01-21 20:07:02 +0100 <Siv> is HACK an acronym or do you mean literal hacking to try to get something odd to work
2022-01-21 20:07:29 +0100 <Siv> ideally i'd have a 2nd machine on the network i can just run all this crud on but i'm in a dual boot setup
2022-01-21 20:08:06 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Ping timeout: 276 seconds)
2022-01-21 20:09:32 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2022-01-21 20:11:02 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2022-01-21 20:11:05 +0100roboguy(~roboguy@user/roboguy)
2022-01-21 20:12:13 +0100 <maerwald> Siv: https://stackoverflow.com/questions/61002681/connecting-to-wsl2-server-via-local-network
2022-01-21 20:12:30 +0100Neuromancer(~Neuromanc@user/neuromancer)
2022-01-21 20:14:56 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2022-01-21 20:15:02 +0100 <Siv> yeah, and i jsut got postgresql to run on wsl2 successfully! ok, so if i forgo the nice docker images i prepared and just run everything in wsl2 with a proxy things should be good :D, we'll see in... an hour or so
2022-01-21 20:15:09 +0100max22-(~maxime@2a01cb0883359800a734b5267d8e6eaf.ipv6.abo.wanadoo.fr) (Ping timeout: 268 seconds)
2022-01-21 20:15:34 +0100mc47(~mc47@xmonad/TheMC47)
2022-01-21 20:17:36 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 20:21:32 +0100tafama(~tafa@user/tafa) (Quit: ZNC - https://znc.in)
2022-01-21 20:21:47 +0100whatif(~user@123.123.223.41)
2022-01-21 20:22:35 +0100alp(~alp@user/alp)
2022-01-21 20:23:03 +0100 <whatif> why there's no splitOn in String but in Text? why there's readFile and yet no readLines? I need to read the file and replace the '\n' char with "<br>" string, how to appendFile to append data in the beginning not the ending?
2022-01-21 20:23:24 +0100 <EvanR> fmap lines readFile
2022-01-21 20:23:40 +0100tafa(~tafa@user/tafa)
2022-01-21 20:23:50 +0100 <whatif> ok
2022-01-21 20:23:50 +0100 <dsal> :t fmap lines . readFile
2022-01-21 20:23:51 +0100 <lambdabot> FilePath -> IO [String]
2022-01-21 20:24:37 +0100 <EvanR> there's an unfortunate package for splitting lists with like 100 different ways to do it
2022-01-21 20:24:39 +0100 <maerwald> whatif: https://hackage.haskell.org/package/split-0.2.3.4/docs/Data-List-Split.html#v:splitOn
2022-01-21 20:24:55 +0100 <EvanR> ^
2022-01-21 20:25:02 +0100 <dsal> :t fmap (intercalate "<br>\n" . lines) . readFile
2022-01-21 20:25:03 +0100 <lambdabot> FilePath -> IO [Char]
2022-01-21 20:25:20 +0100 <whatif> maerwald this isn't came with the standard library
2022-01-21 20:25:27 +0100ksqsf(~user@2001:da8:d800:611:f824:c8ac:863e:f879)
2022-01-21 20:25:33 +0100 <maerwald> whatif: yeah, the standard library isn't very good
2022-01-21 20:25:35 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Remote host closed the connection)
2022-01-21 20:25:39 +0100 <dsal> You can only do so much with the standard library.
2022-01-21 20:25:40 +0100 <whatif> maerwald why splitOn isn't in Data.List?
2022-01-21 20:25:42 +0100 <EvanR> they couldn't agree on what the best split API would be
2022-01-21 20:25:50 +0100 <EvanR> so there is the split package
2022-01-21 20:25:54 +0100 <dsal> whatif: We don't need a standard library that covers every possible use case.
2022-01-21 20:25:54 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 20:26:20 +0100 <EvanR> you can also create your own list split with span and break
2022-01-21 20:26:23 +0100 <EvanR> :t break
2022-01-21 20:26:24 +0100 <lambdabot> (a -> Bool) -> [a] -> ([a], [a])
2022-01-21 20:26:26 +0100 <whatif> dsal: but splitOn is so much used than splitAt
2022-01-21 20:26:26 +0100 <dsal> :t fix
2022-01-21 20:26:27 +0100 <lambdabot> (a -> a) -> a
2022-01-21 20:26:46 +0100 <dsal> whatif: In your code perhaps? I don't use it very much at all.
2022-01-21 20:27:08 +0100 <EvanR> String isn't the greatest option for doing heavy amounts of text processing
2022-01-21 20:27:11 +0100 <dsal> (and when I do, it's in Text)
2022-01-21 20:27:56 +0100zincy_(~zincy@2a00:23c8:970c:4801:f0bc:c4cb:1665:1c67) (Remote host closed the connection)
2022-01-21 20:28:08 +0100 <maerwald> dsal: I'm pretty sure the number of splitOn from extras and split package across hackage is massive
2022-01-21 20:28:18 +0100mc47(~mc47@xmonad/TheMC47) (Ping timeout: 256 seconds)
2022-01-21 20:28:44 +0100briandaed(~briandaed@185.234.208.208.r.toneticgroup.pl)
2022-01-21 20:29:05 +0100 <whatif> what's the name to do `foldl1 <> ["a","bc"]`?
2022-01-21 20:29:21 +0100 <dsal> fold
2022-01-21 20:29:30 +0100 <dsal> > fold ["a", "bc"]
2022-01-21 20:29:31 +0100 <lambdabot> "abc"
2022-01-21 20:29:32 +0100 <EvanR> > join ["a","bc"] -- xD
2022-01-21 20:29:34 +0100 <lambdabot> "abc"
2022-01-21 20:29:52 +0100 <EvanR> > concat ["a","bc"]
2022-01-21 20:29:53 +0100 <lambdabot> "abc"
2022-01-21 20:29:54 +0100 <whatif> why don't name it "reduce"?
2022-01-21 20:29:54 +0100ksqsf(~user@2001:da8:d800:611:f824:c8ac:863e:f879) (Ping timeout: 250 seconds)
2022-01-21 20:30:01 +0100 <dsal> Why would it be named reduce?
2022-01-21 20:30:13 +0100 <EvanR> flatten, which is what join really means
2022-01-21 20:30:20 +0100alexd(~nineonine@50.216.62.2) (Leaving...)
2022-01-21 20:30:20 +0100 <whatif> since lisp and other language did it
2022-01-21 20:30:23 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net) (Ping timeout: 256 seconds)
2022-01-21 20:30:38 +0100 <EvanR> reduce doesn't always
2022-01-21 20:30:47 +0100 <EvanR> i.e. scanl
2022-01-21 20:30:54 +0100 <ski> `reduce' takes a callback, `concat' doesn't
2022-01-21 20:31:10 +0100 <maerwald> yeah, this isn't npm
2022-01-21 20:31:12 +0100 <geekosaur> join is generalized concat
2022-01-21 20:31:19 +0100 <geekosaur> :t join
2022-01-21 20:31:20 +0100 <lambdabot> Monad m => m (m a) -> m a
2022-01-21 20:31:33 +0100 <ski> @type mconcat
2022-01-21 20:31:33 +0100 <geekosaur> % :t join @[]
2022-01-21 20:31:33 +0100 <yahb> geekosaur: [[a]] -> [a]
2022-01-21 20:31:34 +0100 <lambdabot> Monoid a => [a] -> a
2022-01-21 20:31:37 +0100 <ski> @type Data.Semigroup.sconcat
2022-01-21 20:31:38 +0100 <lambdabot> Semigroup a => NonEmpty a -> a
2022-01-21 20:33:00 +0100aliosablack(~chomwitt@ppp-94-67-1-27.home.otenet.gr)
2022-01-21 20:33:10 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 20:33:43 +0100 <whatif> string is [Char] so ["a"...] would be [[Char]],so join can get [Char] which is String, neat
2022-01-21 20:34:20 +0100 <ski> yea, it wasn't totally clear if the strings were just an example, or if it was important that you had a list of lists
2022-01-21 20:34:57 +0100chomwitt(~chomwitt@athedsl-15695.home.otenet.gr) (Ping timeout: 240 seconds)
2022-01-21 20:35:21 +0100 <whatif> appendFile, how to insert at the beginning?
2022-01-21 20:35:30 +0100 <ski> (also, since you asked about `foldl1 (<>)' (and not about `foldl1' itself), "reduce" sounded inappropriate, rather it being applied to some specific callback could be more similar)
2022-01-21 20:35:34 +0100 <whatif> insertFile?
2022-01-21 20:36:46 +0100 <whatif> ski: could `foldl1 <>` == join?
2022-01-21 20:36:54 +0100 <geekosaur> there's no good way to do that, even outside of haskell
2022-01-21 20:37:16 +0100 <geekosaur> rename file to file.old, write new content, append old file to new?
2022-01-21 20:37:36 +0100 <ski> whatif : are you talking about `join :: [[a]] -> [a]' (iow `concat'), or the more general (monadic) meaning of `join' ?
2022-01-21 20:37:38 +0100 <whatif> oh, no, if different m
2022-01-21 20:37:56 +0100 <EvanR> if the OS supported comprehending any file in reverse, maybe it could be done nicely
2022-01-21 20:37:59 +0100 <whatif> ski: never mind
2022-01-21 20:38:06 +0100 <ski> ok
2022-01-21 20:38:23 +0100 <ski> (anyway, `foldl1' doesn't work on empty list ..)
2022-01-21 20:38:31 +0100 <whatif> in list they're equal, not on others
2022-01-21 20:38:47 +0100 <EvanR> efficiently reverse the file, write your data in reverse, then efficiently reverse that file again
2022-01-21 20:38:58 +0100 <whatif> @hoogle insertFile
2022-01-21 20:38:58 +0100 <lambdabot> No results found
2022-01-21 20:39:08 +0100 <whatif> insertFile, could we have a insertFile?
2022-01-21 20:39:26 +0100 <EvanR> files don't support efficient insert
2022-01-21 20:39:29 +0100 <EvanR> in general
2022-01-21 20:39:43 +0100 <whatif> I mean insert the data in the beginning of the file
2022-01-21 20:39:48 +0100 <EvanR> nor that
2022-01-21 20:39:51 +0100 <geekosaur> yes, files do not support that
2022-01-21 20:39:57 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2022-01-21 20:40:18 +0100 <whatif> not others language support that?
2022-01-21 20:40:35 +0100 <geekosaur> [21 19:36:54] <geekosaur> there's no good way to do that, even outside of haskell
2022-01-21 20:40:46 +0100 <geekosaur> has nothing to do with haskell. *files* do not support that
2022-01-21 20:41:17 +0100 <whatif> but I did a lot opening my file and type something at the beginning
2022-01-21 20:41:31 +0100 <geekosaur> editors can do it by rewriting the whole file
2022-01-21 20:41:32 +0100 <[exa]> whatif: you were deceived by your userfriendly editor!
2022-01-21 20:41:36 +0100 <monochrom> In an editor? That's just RAM.
2022-01-21 20:41:42 +0100 <geekosaur> which is the only way to do it
2022-01-21 20:41:57 +0100 <monochrom> Noticely nicely that if you don't hit "save" nothing happens to the file.
2022-01-21 20:42:04 +0100 <geekosaur> there's no way to just stuff some data at the start of a file without rewriting the whole file
2022-01-21 20:42:33 +0100 <whatif> [exa]: we can do readFile and writeFile to do insertFile
2022-01-21 20:42:40 +0100 <[exa]> yeah
2022-01-21 20:42:47 +0100 <monochrom> And if you do hit "save", it's erase-and-start-over-write-it-from-the-very-beginning-to-the-very-end.
2022-01-21 20:43:00 +0100 <monochrom> Try saving a 2GB file some time.
2022-01-21 20:43:02 +0100ec(~ec@gateway/tor-sasl/ec)
2022-01-21 20:43:16 +0100 <[exa]> but that's readfile and writefile, basically makes a new file. If your file is sufficiently big, it's gonna fail
2022-01-21 20:43:27 +0100 <whatif> monochrom: 2GB file, with editors, it's slow?
2022-01-21 20:43:35 +0100 <monochrom> You haven't tried?
2022-01-21 20:43:58 +0100 <whatif> monochrom: my laptop only has 4GB RAM
2022-01-21 20:44:11 +0100 <whatif> open a 2GB file is too hard to my laptop
2022-01-21 20:44:24 +0100 <whatif> if I have a 16GB RAM, may I try it
2022-01-21 20:44:42 +0100 <geekosaur> still slow
2022-01-21 20:44:49 +0100 <geekosaur> editors don't like files that large
2022-01-21 20:45:10 +0100 <EvanR> opening the file isn't the problem, it's inserting stuff at the beginning
2022-01-21 20:45:13 +0100 <whatif> which editor can edit a 2GB file
2022-01-21 20:45:14 +0100 <EvanR> and saving
2022-01-21 20:45:35 +0100 <monochrom> Also the word "open" becomes double-speak at this point.
2022-01-21 20:45:52 +0100 <monochrom> The OS-level "open file" is not the editor-level "open file".
2022-01-21 20:46:22 +0100 <monochrom> In particular, editor-level "open" means OS-level open, read, close.
2022-01-21 20:46:30 +0100 <EvanR> oof
2022-01-21 20:47:05 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2022-01-21 20:47:06 +0100 <geekosaur> and save is open, write entire file, close
2022-01-21 20:47:13 +0100 <monochrom> At some point, as a programmer, you are supposed to understand the following much more than average users:
2022-01-21 20:47:26 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2022-01-21 20:47:35 +0100 <monochrom> 1. The computer system has many layers of abstractions. 2. Every layer lies.
2022-01-21 20:48:48 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net)
2022-01-21 20:48:56 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 20:50:50 +0100zmt00(~zmt00@user/zmt00) (Quit: Leaving)
2022-01-21 20:51:22 +0100Erutuon(~Erutuon@user/erutuon)
2022-01-21 20:52:24 +0100ksqsf(~user@2001:da8:d800:611:bc8a:94b2:c042:3f5f)
2022-01-21 20:53:03 +0100CHUD(~CHUD@cpc142034-slou6-2-0-cust488.17-4.cable.virginm.net) (Ping timeout: 256 seconds)
2022-01-21 20:53:04 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Remote host closed the connection)
2022-01-21 20:53:24 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 20:54:44 +0100 <whatif> how to solve file locking? I readFile then writeFile on the same file?
2022-01-21 20:55:01 +0100 <whatif> is there a @hoogle closeFile
2022-01-21 20:55:03 +0100 <monochrom> OS-depending.
2022-01-21 20:55:09 +0100 <monochrom> err, OS-dependent.
2022-01-21 20:55:13 +0100 <whatif> monochrom: debian
2022-01-21 20:56:00 +0100 <geekosaur> readFile and writeFile are whole-file operations and you should not have to explicitly close, although you may have to force data to avoid laziness holding it open
2022-01-21 20:56:03 +0100 <monochrom> then read up on "unix advisory file locking"
2022-01-21 20:56:41 +0100 <EvanR> readFile, complete your read (tricky if you used the lazy readFile), then writeFile
2022-01-21 20:57:05 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Remote host closed the connection)
2022-01-21 20:57:12 +0100ksqsf(~user@2001:da8:d800:611:bc8a:94b2:c042:3f5f) (Ping timeout: 250 seconds)
2022-01-21 20:57:20 +0100 <whatif> EvanR which one readFile isn't lazy?
2022-01-21 20:57:30 +0100coot(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827)
2022-01-21 20:57:40 +0100 <EvanR> you don't want a strict readFile for [Char]
2022-01-21 20:57:48 +0100 <EvanR> use Data.ByteString or Text
2022-01-21 20:58:09 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Ping timeout: 256 seconds)
2022-01-21 20:58:32 +0100 <monochrom> System.Posix.IO has bindings to the locking operations. Comes with GHC on unixes.
2022-01-21 20:59:07 +0100 <whatif> EvanR the Internal one or the Lazy one?
2022-01-21 20:59:59 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg)
2022-01-21 21:00:34 +0100lavaman(~lavaman@98.38.249.169)
2022-01-21 21:00:35 +0100 <geekosaur> monochrom, I think the "locking" they're talking about is the RTS Handle locking, in this case meaning readFile is lazy and so writeFile fails with a "handle locked" error
2022-01-21 21:00:54 +0100 <monochrom> Oh that.
2022-01-21 21:01:14 +0100 <c_wraith> is that new?
2022-01-21 21:01:22 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 21:01:29 +0100Morrow(~Morrow@bzq-110-168-31-106.red.bezeqint.net)
2022-01-21 21:01:39 +0100 <c_wraith> I remember the combination of readFile and writeFile being happy to just lose all your data for you
2022-01-21 21:01:57 +0100 <geekosaur> it was fixed relatively recently I think
2022-01-21 21:02:17 +0100 <geekosaur> I recall a fair amount of complaining when people started getting the "locked" errors
2022-01-21 21:02:21 +0100 <monochrom> I just don't do that. I don't even do that in shell scripts.
2022-01-21 21:02:33 +0100 <geekosaur> but the Haskell standard requires it specifically because it can lose data otherwise
2022-01-21 21:02:33 +0100 <monochrom> Always write to a temp file then mv.
2022-01-21 21:02:34 +0100 <c_wraith> yeah, it causes data loss even in shell scripts
2022-01-21 21:03:22 +0100 <monochrom> Hell I even wrote a shell script for this "atomic destructive update" design pattern :)
2022-01-21 21:03:27 +0100 <c_wraith> writing to a temp file then moving isn't perfect either. the ext filesystems can still lose your data on a power loss because it syncs data and metadata separately
2022-01-21 21:03:50 +0100 <monochrom> I invested in a UPS for that :)
2022-01-21 21:04:02 +0100 <monochrom> either that, or a laptop battery
2022-01-21 21:04:04 +0100 <c_wraith> you need write/fdatasync/rename
2022-01-21 21:04:12 +0100 <c_wraith> then you at least have atomicity
2022-01-21 21:04:23 +0100ProfSimm(~ProfSimm@176-12-60-137.pon.spectrumnet.bg) (Ping timeout: 256 seconds)
2022-01-21 21:04:24 +0100 <monochrom> Ah nice, thanks, good to know.
2022-01-21 21:05:34 +0100 <monochrom> fdatasink >:)
2022-01-21 21:05:37 +0100 <zzz> what's the best way to force let bindings to be exaustive?
2022-01-21 21:06:05 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 256 seconds)
2022-01-21 21:06:34 +0100 <c_wraith> let bindings don't branch in the pattern match portion - only if there are also guards.
2022-01-21 21:06:43 +0100 <c_wraith> So exhaustiveness checks don't apply.
2022-01-21 21:06:56 +0100 <c_wraith> If you need to match against multiple patterns, you need a case
2022-01-21 21:06:58 +0100 <monochrom> Oh maybe pattern guards then heh
2022-01-21 21:07:04 +0100 <ski> (and the guards "face inwards", not outwards)
2022-01-21 21:07:25 +0100 <zzz> ski: what does it mean?
2022-01-21 21:07:32 +0100 <whatif> EvanR Data.ByteString.readFile and writeFile work
2022-01-21 21:07:46 +0100 <monochrom> But really "exhaustive pattern binding" is an oxymoron.
2022-01-21 21:08:05 +0100 <c_wraith> whatif: those have different semantics - readFile actually reads then closes the entire file before it returns.
2022-01-21 21:08:12 +0100roboguy(~roboguy@user/roboguy) ()
2022-01-21 21:08:21 +0100briandaed(~briandaed@185.234.208.208.r.toneticgroup.pl) (Quit: Lost terminal)
2022-01-21 21:08:30 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2022-01-21 21:09:10 +0100 <monochrom> If your file has 2GB, Data.ByteString.readFile takes 2GB RAM. I thought you were afraid of that.
2022-01-21 21:09:12 +0100 <zzz> ski: i think i see what you mean
2022-01-21 21:09:23 +0100 <whatif> c_wraith: then why System.IO readFile and writeFile locking?
2022-01-21 21:09:28 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 21:09:46 +0100 <ski> in a non-function `let'/`where' binding, `<pat> = <expr>' or `<pat> | <guard> = <expr> | ...', there's still only one pattern that you're matching against, not multiple ones. the guards only serve to determine which value will be matched with the pattern, not to select a branch after matching the pattern
2022-01-21 21:09:46 +0100 <monochrom> Also let me scaremonger you further about killing cache locality...
2022-01-21 21:09:49 +0100 <whatif> monochrom: I don't have that big file, just some text file
2022-01-21 21:10:03 +0100 <c_wraith> whatif: because System.IO readFile doesn't read the entire file before it returns. It just opens it. The value it returns hides a bunch of magic for actually reading from the file on demand.
2022-01-21 21:10:45 +0100coot_(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827)
2022-01-21 21:10:51 +0100 <whatif> c_wraith: then what's its purpose? why it's doing that
2022-01-21 21:10:53 +0100 <EvanR> System.IO readFile is the "gotcha" at the door to the haskell club
2022-01-21 21:10:58 +0100 <geekosaur> and this is why you can find yourself still reading the file when you go to write it
2022-01-21 21:11:18 +0100 <whatif> return immetly after open it?
2022-01-21 21:11:22 +0100 <geekosaur> lazy I/O is convenient. until it bites your ass, at least
2022-01-21 21:11:24 +0100 <ski> contrast with function bindings `f <pat> ... = <expr>; ...' or `f <pat> ... | <guard> = <expr> | ...; ...', where the matching on the argument patterns will select a defining equation, and the any associated guards will select a particular branch
2022-01-21 21:11:27 +0100tolt(~weechat-h@li219-154.members.linode.com) (Quit: WeeChat 2.9)
2022-01-21 21:11:28 +0100 <c_wraith> whatif: it does that so that it bounds memory use. Or at least enables you to bound memory use if you are careful.
2022-01-21 21:11:34 +0100 <ski> zzz : am i making sense ?
2022-01-21 21:11:47 +0100 <c_wraith> whatif: you can open a 10TB file and only ever use a couple kilobytes of memory
2022-01-21 21:12:32 +0100 <monochrom> I don't have a 10TB file, my disk is too small :(
2022-01-21 21:12:42 +0100 <monochrom> Oh! I have /dev/zero :)
2022-01-21 21:12:44 +0100 <c_wraith> Of course, getting that *right* requires you to know enough that you could use a library with a saner interface...
2022-01-21 21:13:00 +0100tolt(~weechat-h@li219-154.members.linode.com)
2022-01-21 21:13:04 +0100 <whatif> c_wraith: in python they would read a certain mount of Bytes of a big file, that's fine too
2022-01-21 21:13:37 +0100Siv(~fuag1@174.127.249.180) (Ping timeout: 240 seconds)
2022-01-21 21:13:42 +0100 <geekosaur> hGet is a thing. or hGetLine.
2022-01-21 21:13:53 +0100 <geekosaur> actually I think it's hGetBuf?
2022-01-21 21:13:53 +0100 <c_wraith> if that's what you want to do, write code that does it.
2022-01-21 21:13:55 +0100 <whatif> monochrom: I only have a 256GB disk
2022-01-21 21:14:01 +0100 <geekosaur> % :t System.IO.hGetBuf
2022-01-21 21:14:02 +0100 <yahb> geekosaur: Handle -> Ptr a -> Int -> IO Int
2022-01-21 21:14:03 +0100 <c_wraith> Don't use readFile
2022-01-21 21:14:21 +0100coot(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827) (Ping timeout: 268 seconds)
2022-01-21 21:14:31 +0100 <geekosaur> Ptr a? seriously?
2022-01-21 21:14:38 +0100 <geekosaur> % :t hGet
2022-01-21 21:14:39 +0100 <yahb> geekosaur: ; <interactive>:1:1: error:; * Variable not in scope: hGet; * Perhaps you meant one of these: `BSL.hGet' (imported from Data.ByteString.Lazy), `BS.hGet' (imported from Data.ByteString)
2022-01-21 21:14:48 +0100 <c_wraith> you went digging for the primitive, you found the primitive :)
2022-01-21 21:14:52 +0100 <geekosaur> come to think of it, I guess yes
2022-01-21 21:14:54 +0100 <ski> @hoogle openFile
2022-01-21 21:14:54 +0100 <lambdabot> System.IO openFile :: FilePath -> IOMode -> IO Handle
2022-01-21 21:14:54 +0100 <lambdabot> GHC.IO.FD openFile :: FilePath -> IOMode -> Bool -> IO (FD, IODeviceType)
2022-01-21 21:14:54 +0100 <lambdabot> GHC.IO.Handle.FD openFile :: FilePath -> IOMode -> IO Handle
2022-01-21 21:15:30 +0100 <zzz> ski: yes, that's what i thought you meant
2022-01-21 21:15:42 +0100skinods
2022-01-21 21:16:23 +0100 <whatif> does anyone use scotty? why that author of scotty doesn't provide a login session?
2022-01-21 21:16:38 +0100 <c_wraith> logging in isn't part of the web.
2022-01-21 21:16:46 +0100 <c_wraith> scotty is a web server
2022-01-21 21:16:54 +0100 <EvanR> HTTP AUTH
2022-01-21 21:16:56 +0100 <whatif> c_wraith: and yesod is a web server?
2022-01-21 21:17:06 +0100 <c_wraith> no, warp is a web server
2022-01-21 21:17:11 +0100 <geekosaur> yesod is an application framework
2022-01-21 21:17:16 +0100 <geekosaur> far moe than a web server
2022-01-21 21:17:20 +0100 <c_wraith> yesod is an application framework built on top of warp
2022-01-21 21:17:21 +0100 <whatif> EvanR how to do http auth?
2022-01-21 21:17:46 +0100 <zzz> it just seems to me it would be useful to have a warning for something like `f x = let Just y = x in y`
2022-01-21 21:18:24 +0100 <EvanR> don't do http auth
2022-01-21 21:18:47 +0100 <EvanR> use a horrible canned auth solution
2022-01-21 21:18:53 +0100 <EvanR> like everyone else
2022-01-21 21:19:13 +0100 <whatif> EvanR how they do?
2022-01-21 21:19:15 +0100 <ski> % let Just y = Nothing in y
2022-01-21 21:19:15 +0100 <yahb> ski: *** Exception: <interactive>:25:5-20: Non-exhaustive patterns in Just y
2022-01-21 21:19:27 +0100 <polyphem> whatif: ther is scotty-session
2022-01-21 21:19:32 +0100 <ski> % :set -Wincomplete-uni-patterns
2022-01-21 21:19:32 +0100 <yahb> ski:
2022-01-21 21:19:34 +0100 <ski> % let Just y = Nothing in y
2022-01-21 21:19:34 +0100 <yahb> ski: ; <interactive>:27:5: warning: [-Wincomplete-uni-patterns]; Pattern match(es) are non-exhaustive; In a pattern binding: Patterns not matched: Nothing; *** Exception: <interactive>:27:5-20: Non-exhaustive patterns in Just y
2022-01-21 21:19:39 +0100 <ski> zzz ^
2022-01-21 21:19:49 +0100 <whatif> polyphem: is it candidate?
2022-01-21 21:19:49 +0100 <zzz> oh yay
2022-01-21 21:20:00 +0100 <c_wraith> ski: that's runtime. There really isn't a compile-time warning for an irrefutable pattern match
2022-01-21 21:20:05 +0100ProfSimm(~ProfSimm@87.227.196.109)
2022-01-21 21:21:11 +0100 <geekosaur> incomplete-uni-patterns is a warning
2022-01-21 21:21:13 +0100 <polyphem> whatif: it provides session functionality , you could build your login on it
2022-01-21 21:21:49 +0100 <whatif> ok
2022-01-21 21:21:55 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 21:21:55 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 21:21:55 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 21:21:56 +0100 <geekosaur> it's separate from full pattern matching because it only applies to things that can't have alternatives (like let-bound values or lambda parameters)
2022-01-21 21:22:10 +0100 <c_wraith> geekosaur: doesn't seem to trigger for me in ghc 9.2.1
2022-01-21 21:22:28 +0100 <ski> % let f x = let Just y = x in y
2022-01-21 21:22:28 +0100 <yahb> ski: ; <interactive>:28:15: warning: [-Wincomplete-uni-patterns]; Pattern match(es) are non-exhaustive; In a pattern binding: Patterns not matched: Nothing
2022-01-21 21:22:44 +0100 <ski> c_wraith ^ ?
2022-01-21 21:22:57 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 240 seconds)
2022-01-21 21:23:05 +0100coot_(~coot@2a02:a310:e03f:8500:5cc8:47c:8ec0:b827) (Quit: coot_)
2022-01-21 21:23:11 +0100 <geekosaur> works for me in 9.2.1
2022-01-21 21:23:51 +0100 <c_wraith> Oh, it's a ghci thing. It doesn't apply to top-level lets in ghci. they have to be in a function body
2022-01-21 21:24:16 +0100 <geekosaur> let in ghci is "special", yeh
2022-01-21 21:24:20 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2022-01-21 21:24:28 +0100 <c_wraith> my mistake
2022-01-21 21:24:29 +0100 <geekosaur> recall that used to be the only syntax for binding a value
2022-01-21 21:24:59 +0100gehmehgeh(~user@user/gehmehgeh)
2022-01-21 21:25:00 +0100 <c_wraith> yeah, but that used the do block let syntax, not let-in
2022-01-21 21:31:10 +0100Tuplanolla(~Tuplanoll@91-159-68-166.elisa-laajakaista.fi)
2022-01-21 21:32:55 +0100 <zzz> why doesn't this throw an exception?: f x = let Just !v = x in const mempty v
2022-01-21 21:33:11 +0100roboguy(~roboguy@user/roboguy)
2022-01-21 21:33:26 +0100 <zzz> f $ Just (undefined :: ())
2022-01-21 21:33:39 +0100unyu(~pyon@user/pyon) (Quit: WeeChat 3.4)
2022-01-21 21:33:46 +0100 <ski> > let !(Just v) = Nothing in const () v
2022-01-21 21:33:47 +0100 <lambdabot> *Exception: <interactive>:3:5-23: Non-exhaustive patterns in Just v
2022-01-21 21:34:10 +0100 <monochrom> > const 4 undefined
2022-01-21 21:34:11 +0100 <lambdabot> 4
2022-01-21 21:34:14 +0100 <monochrom> Because of that.
2022-01-21 21:34:35 +0100 <ski> that `Just !v' basically acts like `~(Just !v)' (since it's a `let'/`where' binding), so the irrefutable `~' is hiding the `!' (which is useless)
2022-01-21 21:34:35 +0100 <zzz> shouldn't the !v force the evaluation on undefined?
2022-01-21 21:34:43 +0100 <zzz> ah
2022-01-21 21:34:49 +0100 <zzz> let bindings are irrefutable
2022-01-21 21:34:51 +0100 <zzz> thanks
2022-01-21 21:34:56 +0100 <ski> np
2022-01-21 21:35:10 +0100 <monochrom> Perhaps you meant !(Just v)
2022-01-21 21:35:35 +0100 <zzz> monochrom: that would have the same effect
2022-01-21 21:35:47 +0100 <ski> no
2022-01-21 21:35:51 +0100 <zzz> no?
2022-01-21 21:35:52 +0100 <ski> (see example above)
2022-01-21 21:36:20 +0100 <ski> if there's an outer `!', then there's no implicit `~' wrapping
2022-01-21 21:36:45 +0100 <polyphem> whatif: theres also wai-hmac-auth
2022-01-21 21:37:00 +0100 <zzz> > let f x = let !(Just v) = x in const mempty v in f (Just (undefined :: ())
2022-01-21 21:37:01 +0100 <lambdabot> <hint>:1:75: error:
2022-01-21 21:37:02 +0100 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)
2022-01-21 21:37:19 +0100 <zzz> > f x = let !(Just v) = x in const mempty v; f (Just (undefined :: ())
2022-01-21 21:37:21 +0100 <lambdabot> <hint>:1:5: error: parse error on input ‘=’
2022-01-21 21:37:24 +0100 <ski> > let f x = let !(Just v) = x in const mempty v in f (Just (undefined :: ()))
2022-01-21 21:37:25 +0100 <lambdabot> ()
2022-01-21 21:37:53 +0100 <monochrom> OK, perhaps you meant !(Just !v)
2022-01-21 21:38:01 +0100 <zzz> :)
2022-01-21 21:38:05 +0100 <ski> ah, if you pass a `Just', then it will match, and `v' will be bound to `undefined'
2022-01-21 21:38:11 +0100 <ski> > let f x = let !(Just !v) = x in const mempty v in f (Just (undefined :: ()))
2022-01-21 21:38:12 +0100 <lambdabot> *Exception: Prelude.undefined
2022-01-21 21:38:29 +0100 <ski> (sorry, i missed your initial `f $ Just ...' thing)
2022-01-21 21:39:19 +0100 <zzz> understood
2022-01-21 21:39:27 +0100 <zzz> let bindings are tricky
2022-01-21 21:42:55 +0100incertia(~incertia@207.98.168.249) (Ping timeout: 256 seconds)
2022-01-21 21:45:25 +0100zmt00(~zmt00@user/zmt00)
2022-01-21 21:45:52 +0100briandaed(~root@185.234.208.208.r.toneticgroup.pl)
2022-01-21 21:48:16 +0100zmt00(~zmt00@user/zmt00) (Client Quit)
2022-01-21 21:48:18 +0100 <Sqaure> I believed there was a "both ::(a -> b) -> (a, a) -> (b, b)" in base? Cannot find it now
2022-01-21 21:49:01 +0100 <EvanR> there is bimap
2022-01-21 21:49:03 +0100 <EvanR> :t bimap
2022-01-21 21:49:04 +0100 <lambdabot> Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
2022-01-21 21:49:20 +0100 <EvanR> :t bimap f f
2022-01-21 21:49:21 +0100 <lambdabot> (Bifunctor p, Show a, Show c, FromExpr b, FromExpr d) => p a c -> p b d
2022-01-21 21:49:22 +0100 <Sqaure> gotcha
2022-01-21 21:49:37 +0100 <EvanR> :t \f -> bimap f f
2022-01-21 21:49:38 +0100 <lambdabot> Bifunctor p => (a -> d) -> p a a -> p d d
2022-01-21 21:49:59 +0100 <EvanR> I think it's not in base but in bifunctors
2022-01-21 21:50:07 +0100 <Hecate> Axman6: I require an explanation at once https://twitter.com/isobelroe/status/1484273468313337856
2022-01-21 21:50:29 +0100 <Hecate> what the fuck is happening in North Queenland
2022-01-21 21:56:28 +0100zmt00(~zmt00@user/zmt00)
2022-01-21 21:57:08 +0100aliosablack(~chomwitt@ppp-94-67-1-27.home.otenet.gr) (Quit: Leaving)
2022-01-21 21:57:31 +0100chomwitt(~chomwitt@2a02:587:dc03:8b00:12c3:7bff:fe6d:d374)
2022-01-21 21:58:35 +0100wootehfoot(~wootehfoo@user/wootehfoot)
2022-01-21 21:59:38 +0100argento(~argent0@168-227-96-53.ptr.westnet.com.ar)
2022-01-21 22:01:21 +0100Siv(~fuag1@174.127.249.180)
2022-01-21 22:03:21 +0100 <EvanR> not haskell
2022-01-21 22:03:57 +0100alp(~alp@user/alp) (Ping timeout: 240 seconds)
2022-01-21 22:04:04 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2022-01-21 22:04:17 +0100 <geekosaur> was wondering what that was doing in here
2022-01-21 22:04:50 +0100pavonia(~user@user/siracusa)
2022-01-21 22:05:23 +0100Hawker_(~pi@user/hawker)
2022-01-21 22:06:05 +0100Hawker_(~pi@user/hawker) (Client Quit)
2022-01-21 22:06:58 +0100xff0x(~xff0x@2001:1a81:52b8:8500:6c95:ecd6:fb54:75ad) (Ping timeout: 250 seconds)
2022-01-21 22:07:06 +0100zebrag(~chris@user/zebrag)
2022-01-21 22:08:00 +0100xff0x(~xff0x@2001:1a81:52b8:8500:732c:1822:8f35:ae7)
2022-01-21 22:12:02 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Remote host closed the connection)
2022-01-21 22:13:02 +0100vysn(~vysn@user/vysn) (Ping timeout: 240 seconds)
2022-01-21 22:14:50 +0100cosimone(~user@93-47-230-23.ip115.fastwebnet.it) (Quit: ERC (IRC client for Emacs 27.1))
2022-01-21 22:16:06 +0100johnjaye(~pi@173.209.65.233)
2022-01-21 22:16:41 +0100timCF(~timCF@m91-129-100-224.cust.tele2.ee)
2022-01-21 22:19:56 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2022-01-21 22:20:02 +0100 <timCF> Hello! I'm trying to compile executable with ghc, and doing it inside docker container. Executable compiles fine, but I'm not able to run it oh host system for some reason (it crashes with error "No such file or directory"). I do suspect it's something related to linking, tried to build inside alpine and ubuntu containers - the same result. Host system is ubuntu. Did anybody experienced something similar?
2022-01-21 22:21:33 +0100 <geekosaur> did it say which file it couldn't find?
2022-01-21 22:21:50 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2022-01-21 22:22:12 +0100dsrt^(~dsrt@207.182.73.202) (Ping timeout: 256 seconds)
2022-01-21 22:22:13 +0100califax(~califax@user/califx) (Remote host closed the connection)
2022-01-21 22:22:13 +0100 <geekosaur> (if it claimed the executable, but it's there, it might be missing the dynamic loader)
2022-01-21 22:22:32 +0100califax(~califax@user/califx)
2022-01-21 22:22:57 +0100 <timCF> No, full error looks like "bash: ./build/my-exe: No such file or directory"
2022-01-21 22:23:29 +0100 <timCF> Executable is definitely there, 14MB size
2022-01-21 22:23:57 +0100briandaed(~root@185.234.208.208.r.toneticgroup.pl) (Ping timeout: 240 seconds)
2022-01-21 22:24:12 +0100stevenxl(~stevenxl@c-73-72-2-81.hsd1.il.comcast.net) (Quit: leaving)
2022-01-21 22:25:25 +0100 <timCF> Inside docker container executable actualy runs file
2022-01-21 22:25:29 +0100 <timCF> * fine
2022-01-21 22:25:33 +0100 <dsal> It's probably a ld library
2022-01-21 22:26:02 +0100 <dsal> ldd ./build/my-exe
2022-01-21 22:26:07 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41)
2022-01-21 22:26:08 +0100_ht(~quassel@82-168-34-160.fixed.kpn.net) (Remote host closed the connection)
2022-01-21 22:26:15 +0100sheb(~sheb@31.223.228.71) (Quit: Leaving)
2022-01-21 22:27:12 +0100 <timCF> dsal: interesing, it shows a lot of stuff
2022-01-21 22:27:16 +0100 <geekosaur> objdump -j .interp -s ./build/myexe
2022-01-21 22:27:40 +0100 <geekosaur> this should print out a filename, although as a hex+char dump. make sure that file exists
2022-01-21 22:27:40 +0100 <timCF> "libffi.so.8 => not found" - this is one of the lines
2022-01-21 22:27:55 +0100 <timCF> it might be an actual issue?
2022-01-21 22:28:02 +0100 <geekosaur> yes
2022-01-21 22:28:21 +0100 <geekosaur> sounds like you are missing a bunch of shared objects and possibly the core loader
2022-01-21 22:28:34 +0100MajorBiscuit(~MajorBisc@86-88-79-148.fixed.kpn.net)
2022-01-21 22:29:05 +0100 <geekosaur> typically when the file itself is claimed to be missing but is there, it's the loader that is missing. run the objdump command I specified above and see if the named file exists
2022-01-21 22:29:47 +0100 <geekosaur> on my system it names /lib64/ld-linux-x86-64.so.2
2022-01-21 22:30:59 +0100 <zzz> Sqaure: join bimap is one of my go to's
2022-01-21 22:31:03 +0100 <timCF> geekosaur: it gives this output, but honestly I do have no idea what does it mean :)
2022-01-21 22:31:07 +0100 <zzz> @type join bimap
2022-01-21 22:31:07 +0100 <lambdabot> Bifunctor p => (c -> d) -> p c c -> p d d
2022-01-21 22:31:08 +0100 <timCF> geekosaur: https://gist.github.com/21it/80d95734d9e17973c61da465d45ee5c4
2022-01-21 22:31:46 +0100 <zzz> > join bimap succ (6,8)
2022-01-21 22:31:47 +0100 <lambdabot> (7,9)
2022-01-21 22:32:37 +0100 <EvanR> V2 a = V2 !a !a functor is handy
2022-01-21 22:32:37 +0100n3rdy1(~n3rdy1@2600:1700:4570:3480::41) (Ping timeout: 240 seconds)
2022-01-21 22:32:40 +0100 <geekosaur> timcf, welp. you got a loader form nix somehow
2022-01-21 22:33:27 +0100 <timCF> yeah, nix is a lot of fun, and it's always working until it's not
2022-01-21 22:33:30 +0100 <geekosaur> there's a patchelf command you can use to fix it
2022-01-21 22:33:56 +0100 <geekosaur> https://github.com/NixOS/patchelf
2022-01-21 22:34:53 +0100 <timCF> geekosaur: thanks a lot, I'll take a look!
2022-01-21 22:35:23 +0100 <geekosaur> can probabl;y install that via nix if you have nix installed on the host, or arrange to do it in the docker container
2022-01-21 22:35:24 +0100 <geekosaur> look for the host (not nix) loader, which stands a good chance of being where I said mine was because I run ubuntu
2022-01-21 22:35:24 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Remote host closed the connection)
2022-01-21 22:36:13 +0100infinity0(~infinity0@occupy.ecodis.net) (Ping timeout: 240 seconds)
2022-01-21 22:37:04 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2022-01-21 22:38:09 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2022-01-21 22:38:24 +0100infinity0(~infinity0@occupy.ecodis.net)
2022-01-21 22:40:07 +0100alMalsamo(~alMalsamo@gateway/tor-sasl/almalsamo)
2022-01-21 22:40:22 +0100 <timCF> geekosaur: do you think with this util I'll be able to run on ubuntu executable which was built on alpine image?
2022-01-21 22:41:09 +0100 <geekosaur> that one is less likely, although I think alpine builds things statically by default so they should work pretty much anywhere
2022-01-21 22:43:20 +0100 <geekosaur> (sadly if it's also using nix that may be false and you would again need patchelf. and would again have to watch for missing/wrong version shared objects
2022-01-21 22:43:46 +0100 <geekosaur> )
2022-01-21 22:45:34 +0100incertia(~incertia@207.98.163.88)
2022-01-21 22:46:32 +0100 <timCF> I only heard buzz words like musl (used by alpine) and glibc (used by ubuntu) and that there will be some problems related to this. I'll try anyway, because alpine image is much smaller
2022-01-21 22:47:47 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-21 22:49:13 +0100ukari(~ukari@user/ukari) (Ping timeout: 256 seconds)
2022-01-21 22:51:45 +0100 <maerwald> there are no problems
2022-01-21 22:52:51 +0100 <geekosaur> there would be problems going the other way but alpine executable should work fine unless nix builds make them dynamic for some reason
2022-01-21 22:53:19 +0100 <maerwald> (there are no problem with building static binaries in alpine docker containers)
2022-01-21 22:56:35 +0100Siv(~fuag1@174.127.249.180) (Ping timeout: 256 seconds)
2022-01-21 22:56:37 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2022-01-21 22:57:06 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd) (Ping timeout: 276 seconds)
2022-01-21 23:02:18 +0100coot(~coot@89-64-85-93.dynamic.chello.pl)
2022-01-21 23:03:20 +0100ukari(~ukari@user/ukari)
2022-01-21 23:04:36 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com)
2022-01-21 23:04:36 +0100wroathe(~wroathe@206-55-188-8.fttp.usinternet.com) (Changing host)
2022-01-21 23:04:36 +0100wroathe(~wroathe@user/wroathe)
2022-01-21 23:06:03 +0100roboguy(~roboguy@user/roboguy) ()
2022-01-21 23:08:08 +0100alphabeta(~kilolympu@31.205.200.235) (Remote host closed the connection)
2022-01-21 23:08:29 +0100wyrd(~wyrd@gateway/tor-sasl/wyrd)
2022-01-21 23:09:37 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 256 seconds)
2022-01-21 23:10:22 +0100deadmarshal(~deadmarsh@95.38.113.215) (Ping timeout: 256 seconds)
2022-01-21 23:11:43 +0100alphabeta(~kilolympu@31.205.200.235)
2022-01-21 23:12:23 +0100fendor_(~fendor@178.115.77.166.wireless.dyn.drei.com) (Remote host closed the connection)
2022-01-21 23:12:26 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f)
2022-01-21 23:16:37 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:494b:f936:f65f:424f) (Ping timeout: 240 seconds)
2022-01-21 23:17:43 +0100alp(~alp@user/alp)
2022-01-21 23:19:35 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl)
2022-01-21 23:20:30 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Ping timeout: 276 seconds)
2022-01-21 23:21:50 +0100max22-(~maxime@2a01cb0883359800536f505f6298e408.ipv6.abo.wanadoo.fr)
2022-01-21 23:24:55 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net) (Ping timeout: 256 seconds)
2022-01-21 23:25:22 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2022-01-21 23:28:52 +0100Siv(~fuag1@174.127.249.180)
2022-01-21 23:29:18 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2022-01-21 23:33:35 +0100tommd(~tommd@67-42-147-226.ptld.qwest.net)
2022-01-21 23:33:58 +0100coot(~coot@89-64-85-93.dynamic.chello.pl) (Quit: coot)
2022-01-21 23:44:55 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2022-01-21 23:53:49 +0100merijn(~merijn@c-001-001-018.client.esciencecenter.eduvpn.nl) (Ping timeout: 256 seconds)
2022-01-21 23:56:50 +0100boxscape_(~boxscape_@p4ff0b9d5.dip0.t-ipconnect.de)
2022-01-21 23:57:10 +0100 <boxscape_> can I say in my cabal.project file that hpack should be used for a particular repository to create the cabal file?
2022-01-21 23:57:48 +0100AWizzArd(~code@gehrels.uberspace.de) (Changing host)
2022-01-21 23:57:48 +0100AWizzArd(~code@user/awizzard)
2022-01-21 23:58:10 +0100 <boxscape_> (because the repository only has a package.yaml file)