<    April 2017    >
Su Mo Tu We Th Fr Sa  
                   1  
 2  3  4  5  6  7  8  
 9 10 11 12 13 14 15  
16 17 18 19 20 21 22  
23 24 25 26 27 28 29  
30
00:00 infinity0 joined
00:00 newhoggy joined
00:01 takle joined
00:01 <monochrom> http://hackage.haskell.org/package/category-printf
00:02 <monochrom> No examples. What they complain about poor documentation applies. :)
00:02 infinity0 joined
00:05 <Cale> No examples?
00:05 infinity0 joined
00:06 <Cale> monochrom: No examples of what?
00:08 sternenseemann left
00:08 infinity0 joined
00:09 mjora7 joined
00:10 <mjora7> Is there a Haskell framework that solves the same problems as Django (Python), Rails (Ruby), Express (JS)?
00:10 dbmikus joined
00:11 infinity0 joined
00:11 augur joined
00:12 <Cale> mjora7: There are several web frameworks for Haskell... perhaps the closest to rails would be Yesod, but personally, it's not my favourite.
00:12 newhoggy joined
00:12 <mjora7> Cale: What is the most popular one? That seems safest to me (mostly because there will be more educational material on it).
00:12 <Cale> mjora7: Have a look at Happstack or Snap
00:12 <Cale> Well, they're all reasonably popular and well documented
00:12 <EvanR> how popular stuff becomes popular...
00:13 <Cale> We're using Snap in production where I work
00:13 <EvanR> no matter how good/bad
00:13 infinity0 joined
00:14 mac10688 joined
00:14 peterbecich joined
00:14 augur joined
00:15 <mjora7> Thanks for the suggestions
00:16 takle joined
00:16 conal joined
00:16 danthemyth joined
00:17 halogenandtoast joined
00:18 <saylu> Hey folks! Trying to read in a list of URLs from a CSV and having trouble with the url encoding.
00:19 <saylu> Some of the URLs have special characters like this: …tanaka®…
00:19 <saylu> I’m getting lost because I’m not sure which `readFile` to use (System.IO? Text.IO? ByteString.IO?) to avoid getting those characters escaped with `\174` and so on.
00:19 DillyD joined
00:19 <saylu> Of course, then I need to parse it, for which I’m planning to use `http-types` to just go ahead and URL encode it like this: …tanaka%C2%AE…
00:19 <saylu> Any advice here?
00:19 mjora7 joined
00:20 <Cale> saylu: If you don't want to decode the special characters and would prefer to deal with raw bytes, then ByteString. Otherwise the stuff in Text will decode them
00:20 <saylu> I thought the Text package handled UTF-16, but playing around with it I'm getting escaped characters. I'm sure I'm missing something here.
00:20 <saylu> https://www.irccloud.com/pastebin/gp70rZrx/
00:20 <Eduard_Munteanu> saylu, there is no escaping in any of those, that's just for display purposes when you show them
00:21 mbw joined
00:21 <Cale> Try using putStrLn to print the Text back out
00:21 <EvanR> Text is an abstract unicode text type, UTF-16 shouldnt factor into anything you do with it
00:21 <EvanR> (except for one detail)
00:21 <EvanR> minor
00:22 newhoggy joined
00:22 <EvanR> UTF-16 is a property of ByteStrings
00:22 lifter joined
00:23 <saylu> Hmm OK. Let me check on that a bit more, thanks
00:23 takle joined
00:24 <saylu> Hey, would you look at that -- using Data.Text.putStrLn does give the same back out.
00:25 <EvanR> and that is yet another thing... putStrLn sends to the output system an encoding that your terminal properly displays because of locale (or by accident)
00:26 ubsan_ joined
00:26 watabou joined
00:26 <EvanR> we really should upgrade all links to be able to carry unicode directly to avoid these issues ;)
00:27 <EvanR> QAM-1114112
00:27 kylepotts joined
00:28 peterbecich joined
00:28 fowlslegs joined
00:28 <mjora7> I'm just afraid that figuring out how to do database transactions and authentication and various other backend stuff in Haskell frameworks that are significantly less popular than the mainstream frameworks is going to be a nightmare for me
00:29 <mjora7> Or am I totally wrong about that?
00:29 <EvanR> i found transactions to be straightforward, but i havent used the most popular frameworks
00:29 <Cale> It's certainly no worse than in mainstream frameworks
00:29 <EvanR> authentication is a nightmare no matter what
00:29 peterbecich joined
00:30 <EvanR> i end up writing it myself in any system
00:30 peterbecich joined
00:31 <mjora7> Yeah I don't want to every write my own authentication haha
00:31 peterbecich joined
00:32 newhoggy joined
00:34 justin3 joined
00:34 <mjora7> ever*
00:34 jsgrant__ joined
00:34 a3Dman joined
00:35 blender1 joined
00:35 wroathe joined
00:37 m0cesta joined
00:41 peterbecich joined
00:41 <Eduard_Munteanu> About that, does persistent even do transactions?
00:41 <mbw> Hello again. Still struggling with Repa. What is the idiomatic way of "zipWithing" more than two arrays? Repa does not seem to have anything in the way of zipWith3 etc., but there are function zip3 and up in Data.Array.Repa.Repr.Unboxed. Should I use those, or should I prefer something along the lines of traverse or interleave?
00:42 <EvanR> i cant imagine a popular database framework not doing transactions... besides mongo, doesnt count
00:43 <Eduard_Munteanu> I have assumed Yesod's runDB enclosed a transaction, but that can't be right because you can intersperse logic with database operations.
00:44 <EvanR> which you are supposed to do in SQL anyway
00:44 <Cale> That isn't right, you absolutely can intersperse logic with database transactions
00:44 <Eduard_Munteanu> Oh, hm.
00:44 <EvanR> especially the decision to abort
00:44 <Cale> The DB will give you the results of intermediate computations in your transaction
00:45 <EvanR> but also the decision to do random other IO
00:45 jer1 joined
00:46 roconnor joined
00:46 leifmetcalf joined
00:47 ckubrak joined
00:49 <orion> What's wrong with that?
00:50 <Eduard_Munteanu> Nothing, I assumed it was more constrained than non-transactional operations.
00:50 roconnor joined
00:51 <EvanR> well STM has a lot more guarantees
00:51 <EvanR> a transaction can only depend on STM variables
00:51 <EvanR> and the inputs
00:51 <Eduard_Munteanu> Yeah, I was thinking of something like that.
00:52 <EvanR> you can retry as much as you want without causing weird stuff
00:52 <EvanR> not the case in SQL
00:52 <EvanR> but is nice when you set it up like that
00:54 carlosda1 joined
00:54 takle joined
00:56 a3Dman joined
00:57 blym_ joined
01:00 <saylu> Well, well. If you so much as open one of these CSVs with Excel it automatically intersperses weird characters.
01:00 <saylu> That's the root of the problem
01:00 <saylu> God, what an afternoon
01:00 <saylu> Thanks for the help guys
01:00 abhiroop joined
01:00 slack1256 joined
01:00 <EvanR> probably an encoding issue
01:01 <EvanR> excel has permanently had unicode problems as far as i know
01:01 <saylu> Yea. I have most of the original CSVs that are fine, but a handful that were opened and briefly edited before they were sent to me
01:01 <saylu> Testing had been fine but when I got to those, suddenly...issues! but I didn't think to check on that.
01:03 shayan_ joined
01:06 blym_ joined
01:06 wroathe joined
01:09 Welkin joined
01:10 <mbw> I hope it's not bad etiquette, but I'd like to ask my previous question again. Is there an idiomatic way of applying a zipWith function to more than two Repa arrays? While I can apply zip3/4/... to unboxed Repa vectors, these operations do not return a delayed representation and may not be the best way to go about this. On the other hand, only zipWith exists, no zipWith3 etc.
01:11 <Welkin> > (+) <$> [1,2,3] <*> [4,5,6]
01:11 <lambdabot> [5,6,7,6,7,8,7,8,9]
01:12 <Welkin> > (+) <$> [1,2,3] <*> [1, 1, 1] <*> [2, 2, 2]
01:12 <lambdabot> [2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4]
01:12 <Welkin> oh yeah
01:12 <EvanR> the heck
01:14 <Welkin> mbw: you can always apply it multiple times
01:14 ckubrak joined
01:14 <dmj`> someone added AI to lambdabot
01:15 <Welkin> no dmj`, you just have me on ignore
01:16 roboguy` joined
01:16 <Welkin> > hello dmj`
01:16 <lambdabot> <hint>:1:12: error:
01:16 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)
01:17 bhiliyam joined
01:17 <pacak> > (,,) <$> ZipList [1..5] <*> ZipList "abcde" <*> ZipList [100..]
01:17 <Welkin> > "dmj`: I am outside your window"
01:17 <lambdabot> ZipList {getZipList = [(1,'a',100),(2,'b',101),(3,'c',102),(4,'d',103),(5,'e...
01:17 <lambdabot> "dmj`: I am outside your window"
01:17 <pacak> > getZipList $ (,,) <$> ZipList [1..5] <*> ZipList "abcde" <*> ZipList [100..]
01:17 <lambdabot> [(1,'a',100),(2,'b',101),(3,'c',102),(4,'d',103),(5,'e',104)]
01:17 <* dmj`> gasps
01:18 <pacak> mbw: You might need to write some instances for that. Or might not.
01:18 <rotaerk> hmm what's needed to allow (+) <$> [1,2,3] <*> [1,1,1] <*> [2,2,2] to work?
01:18 <rotaerk> it doesn't work in my GHCI
01:18 noddy joined
01:18 <pacak> rotaerk: import Control.Applicative?
01:18 <lyxia> mbw: the easiest seems to be either zipWith or fromFunction
01:18 <EvanR> hear hear how is + applying to 3 lists
01:18 <pacak> rotaerk: Are you on some ancient version?
01:18 <rotaerk> no, that's already in the prelude
01:19 <mbw> Welkin: Surely all ways lead to Rome. It's just that it feels kinda off. I could probably also do some fancy interleavings. Specifically it's something like p_uv = sum_i (n_i * c_ui * c_vi), with {i,u,v} being indices.
01:19 <mbw> I thought that would just be a sumAllS/P . zipWith3 ...
01:19 <rotaerk> :t (+) <$> [1,2,3] <*> [1,1,1] <*> [2,2,2]
01:19 <lambdabot> Num b => [b]
01:20 <rotaerk> for me, ghci says: :: (Num (a -> b), Num a) => [b]
01:20 <mbw> That would be the function invoked by fromFunction.
01:20 alqatari joined
01:21 <lyxia> rotaerk: someone just defined it in lambdabot
01:21 <rotaerk> :t (<*>)
01:21 <lambdabot> Applicative f => f (a -> b) -> f a -> f b
01:21 <lyxia> it's not in any standard location
01:21 <pacak> :t (+)
01:21 <lambdabot> Num a => a -> a -> a
01:21 kylepotts joined
01:21 <rotaerk> :t (<$>)
01:21 <lambdabot> Functor f => (a -> b) -> f a -> f b
01:21 <pacak> > let 2 + 2 = 5 in 2 + 2
01:21 <lambdabot> 5
01:22 <rotaerk> they all look standard though
01:22 <lyxia> rotaerk: "it" being instance Num b => Num (a -> b)
01:22 <rotaerk> ah
01:22 subttle joined
01:24 butterthebuddha joined
01:25 hybrid joined
01:25 uiop_ joined
01:28 matt179 joined
01:28 taktoa joined
01:28 <mbw> Or let me ask this another way (since I'm sure I can figure out a way to do this via some fancy interleaving or something). The problem I see with using zip3 is that, although it is an O(1) operation, it returns a manifest Unboxed Array. Am I correct in that you should try to make a pipeline of Delayed representations and computeS/P as late as possible?
01:30 takle joined
01:30 wroathe joined
01:32 jer1 joined
01:34 <lyxia> yes
01:35 <lyxia> actually no
01:35 <lyxia> zip3 is just that cheap
01:35 Supersonic112_ joined
01:35 blueonyx joined
01:35 tnks joined
01:37 <mbw> But in my case I have to zip a vector, and two slices. Since zip3 expects Array Us, I have to compute those.
01:37 blym_ joined
01:37 eyen joined
01:37 a3Dman joined
01:37 Goplat joined
01:42 <lyxia> okay, zip3 is cheap if you actually have unboxed vectors in the first place
01:42 tswe_tt joined
01:43 <lyxia> if you don't just make a function and (unsafe)index into your vectors with the index provided by fromFunction
01:43 <mbw> Maybe I am simply seeing too many nails to hammer at with sum . zipWith
01:44 <mbw> Repa is just to unusual if you would normally just write a triple for loop.
01:45 <mbw> *too
01:46 fXl joined
01:47 butterthebuddha joined
01:48 filterfish joined
01:48 jangsutsr joined
01:48 takle joined
01:48 blym_ joined
01:49 splanch joined
01:50 butterthebuddha joined
01:50 Kenix joined
01:50 mr_sm1th joined
01:53 systemfault joined
01:55 systemfault joined
01:55 carlosda1 joined
01:58 conal joined
01:59 tommd joined
02:00 takle joined
02:00 hucksy_ joined
02:01 newhoggy joined
02:02 jangsutsr left
02:03 Argue_ joined
02:03 sleffy joined
02:03 mbw joined
02:04 hexfive joined
02:05 gmhafiz joined
02:07 augur joined
02:08 newhoggy joined
02:09 Noldorin joined
02:10 abhiroop joined
02:10 RayNbow` joined
02:12 eyen joined
02:12 mjora7 joined
02:12 blym_ joined
02:13 takle joined
02:15 peterbec` joined
02:16 kylepotts joined
02:16 roboguy` joined
02:17 subttle joined
02:18 danthemyth joined
02:22 sleffy joined
02:22 biglambda joined
02:23 brynedwards joined
02:24 <biglambda> What is neccessary for hackage to index a library. I’d like to help get the qtah library working: https://hackage.haskell.org/package/qtah-qt5
02:24 blender1 joined
02:25 takle joined
02:27 <geekosaur> someone has to upload it
02:28 wroathe joined
02:30 filterfish_ joined
02:30 filterfish joined
02:30 filterfish_ joined
02:32 freeside joined
02:33 Beelsebob joined
02:33 schwuk joined
02:35 sleffy joined
02:36 flatmap13 joined
02:38 Beelsebob left
02:42 roboguy` joined
02:42 subttle joined
02:43 takle joined
02:43 roboguy` joined
02:44 roboguy` joined
02:44 e14 joined
02:50 jmiven joined
02:51 fXl joined
02:51 exferenceBot joined
02:53 biglambda joined
02:55 takle joined
02:56 carlosda1 joined
02:56 hexagoxel joined
02:56 augur joined
02:58 <EvanR> how big is a big Integer?
02:59 sz0 joined
03:00 <geekosaur> limited by memory, at least for the default gmp backend
03:01 <EvanR> when it exceeds the value of a small Int, but isnt much bigger than that, how many bytes does i end up taking
03:01 <EvanR> does gmp expose that
03:03 conal joined
03:04 Costar joined
03:04 <geekosaur> doesn't look like it
03:04 <geekosaur> at leats, not readily
03:04 andrei joined
03:04 <geekosaur> I can get digits, or I can get "limbs"
03:04 subttle joined
03:05 m3adi3c joined
03:05 <EvanR> apparently Integer's backend got some attention https://ghc.haskell.org/trac/ghc/wiki/ReplacingGMPNotes
03:05 <andrei> Is there a way to use lenses in order to zip a list onto two fields? I have data X = { a :: [Y], b :: [Y]}, and I want to give every a and b an identifier. Right now I do a zipWith on each field independently.
03:06 <EvanR> "if integer-simple is fast enough, then this solves all the issues with integer-gmp"
03:06 <andrei> And use their length to make ti unique
03:06 insitu joined
03:06 darjeeling_ joined
03:08 newhoggy joined
03:08 wroathe joined
03:09 takle joined
03:10 noddy joined
03:10 kylepotts joined
03:12 <EvanR> so haskell programs cant ffi to gmp normally since its already linked in and taking up those symbols, or something
03:12 eyen joined
03:13 <geekosaur> actually haskell programs can ffi to it fine, it's C programs that can't use it because they'd be manipulating Haskell's heap
03:13 <geekosaur> there's at least one library on hackage that does ffi to gmp
03:14 <geekosaur> unless gmp is statically linked but then you'd have problems anyway
03:14 <EvanR> man this licensing paragraph seems really bad
03:15 <EvanR> for people that care about licensing. i know a lot of haskell libs are BSD, but static GMP triggers a phase shift of the entire compiled program and ghc itself (???) to be LGPL
03:15 eacameron joined
03:15 <geekosaur> yep
03:16 <geekosaur> that's precisely why some effort was put in to bring integer-simple up to snuff (both making a ghc with it, and making its performance not be utterly terrible)
03:16 <rotaerk> hmm is there some way to derive a typeclass instance for a type *after* the declaration of that type
03:16 <geekosaur> -XStandaloneDeriving
03:16 <rotaerk> thanks
03:16 <geekosaur> deriving instance Foo Bar
03:17 subttle joined
03:18 bhiliyam joined
03:19 jmcarthur joined
03:20 abhiroop joined
03:20 <EvanR> whats the latest on integer-simple then?
03:21 filterfish joined
03:21 <geekosaur> unclear. it is believed that some commercial entities are using it, but they don't talk about it
03:21 <EvanR> heh
03:22 <geekosaur> (considering some of the commercial entities that I've worked with, admittedly indirectly, I can well imagine (a) severe allergy to GPL in any form (b) severe allergy to talking about anything they do
03:24 felixsch__ joined
03:25 jer1 joined
03:27 <freeside> unbalanced parentheses after token "do"
03:27 takle joined
03:28 wroathe joined
03:30 chc4 joined
03:30 syrius_ joined
03:31 <geekosaur> normal for me >.>
03:32 halogenandtoast joined
03:32 <EvanR> gotta love how trivial Integer makes the calculations to synchronize monotonic clock nanoseconds and samples per second!
03:34 <EvanR> if i compile GMP into the binary, and run it on an arcade machine, which accepts quarters, does that mean i have to fork over the source code on demand
03:35 <freeside> :)
03:35 <monochrom> I don't think the quarter matters.
03:37 <freeside> use the arcade machine's LEDs as a communications channel to slowly blink out the source code over time
03:38 <EvanR> (i found out recently that LEDs can transmit data in the gbps range, or theoretically more, due to bandwidth of visible light)
03:38 beerdrop joined
03:38 <EvanR> (through air)
03:38 subttle joined
03:39 <freeside> i heard of an attack on a network switch once whose port LEDs were synchronized with the TX/RX -- attacker just drive up outside and focused a telephoto lens on the switch.
03:39 <EvanR> tell me another one
03:40 <freeside> after that the manufacturer had to decouple
03:41 tommd joined
03:43 <freeside> http://applied-math.org/optical_tempest.pdf
03:46 <frontendloader> EvanR: funny that transmitting data with LEDs should come up in here, I'm dorking around with an internet of things device that gets config data from your phone through a light sensor
03:46 <frontendloader> and your phone screen flashing rapidly
03:46 filterfish joined
03:47 <EvanR> next thing itll be black monoliths
03:48 Destol joined
03:48 <geekosaur> and black helicopters
03:49 abhiroop joined
03:51 subttle joined
03:53 <freeside> is it purelifi or something else?
03:53 vaibhavsagar joined
03:54 wroathe joined
03:55 <freeside> ah, http://www.es.ewi.tudelft.nl/msc-theses/2015-Vasilakis.pdf
03:56 esph joined
03:56 carlosda1 joined
03:59 filterfish joined
04:00 filterfish_ joined
04:02 Xanather joined
04:02 insitu joined
04:04 wroathe joined
04:05 esph joined
04:05 kylepotts joined
04:08 dfeuer joined
04:09 a3Dman joined
04:11 pavonia joined
04:11 takle joined
04:13 geekosaur joined
04:14 wroathe joined
04:14 systemfault joined
04:16 subttle joined
04:18 filterfish joined
04:19 danthemyth joined
04:20 m3adi3c joined
04:21 BartAdv joined
04:22 insitu joined
04:22 mjora7 joined
04:24 splanch joined
04:30 Neurocam joined
04:31 fieldsofgold joined
04:31 mac10688 joined
04:32 shinubi joined
04:32 shinubi left
04:32 subttle joined
04:34 wroathe joined
04:35 Neurocam left
04:35 Guest48456 joined
04:38 filterfish_ joined
04:41 takle joined
04:42 manjaro-kde5-- joined
04:43 subttle joined
04:44 <EvanR> sdl2's open audio spec type wants a field of type forall actualSampleType. AudioFormat actualSampleType -> IOVector actualSampleType -> IO ()
04:44 <EvanR> i mandated actualSampleType to be Int16, but then my callback must be polymorphic for it to type check
04:45 <EvanR> so not sure how to treat that IOVector
04:45 wroathe joined
04:46 ali_bush joined
04:46 ali_bush joined
04:46 <EvanR> ah hmm, pattern match on the audio format argument
04:47 <EvanR> sweet
04:47 <EvanR> haskell made easy
04:48 takle joined
04:55 wroathe joined
04:57 carlosda1 joined
04:59 kylepotts joined
05:01 <Engen> hey everyone, I'm just trying to do some exercises with propositional logic and am having some trouble understanding the following syntax
05:01 <Engen> http://wklej.org/id/3093872/
05:02 <Engen> is line 2 simply defining two functions
05:02 <Engen> or is it defining that the variables true and false are of type PropFormula
05:03 <alx741> Engen: two variables of type PropFormula, which has constructors PTrue and PFalse
05:04 <Engen> http://wklej.org/hash/33a5917ef3b/ is the full given paste if it helps
05:05 wroathe joined
05:05 filterfish joined
05:07 takle joined
05:08 <Engen> alx741: by being constructors, they always have the given values?
05:12 crawfoj0 joined
05:14 kylepotts joined
05:15 takle joined
05:16 wroathe joined
05:16 <pavonia> They never change their values
05:18 harfangk joined
05:18 bhiliyam joined
05:21 dresuer joined
05:22 subttle joined
05:22 takle joined
05:24 soniku joined
05:25 <alx741> Engen: PTrue and PFalse *are* the values in this case
05:26 jer1 joined
05:27 Sose_ joined
05:27 rcschm joined
05:30 peterbec` joined
05:30 zach_ joined
05:34 eklavya joined
05:36 wroathe joined
05:39 kody joined
05:40 FreeBirdLjj joined
05:41 takle joined
05:41 steeze joined
05:44 numee joined
05:46 wroathe joined
05:46 <srk> looks like it is possible to compose pipes mvc and vinylgl into live plotting library \o/
05:49 abhiroop joined
05:51 nicknovitski joined
05:57 wroathe joined
05:57 takle joined
05:58 dfeuer joined
05:58 carlosda1 joined
05:59 caumeslasal joined
06:01 vaibhavsagar joined
06:04 windsing joined
06:05 abhiroop joined
06:06 <Engen> I'm not quite sure understanding where my function is going wrong here: http://wklej.org/hash/12d220293ca/ in the 3rd and 4th guard, the results that are either multiplied or added together are all Bool
06:06 wroathe joined
06:07 <Engen> yet the error I get from ghci when I try to load the function is "Couldn't make expected type `Bool' with actual type `PropFormula' referring to the PAnd a b and POr a b lines
06:07 mohsen_ joined
06:08 <pavonia> Engen: "PAnd a b" is a value of type PropFormula, not type Bool
06:08 <cocreature> Engen: "PAnd a b" is of type "PropFormula" but "evalSimple a && evalSimple b" is of type "Bool". you can only compare things of the same type with "=="
06:08 mjora7 joined
06:09 teggi joined
06:09 <pavonia> Engen: You probably don't want to use guards there but just use pattern matching
06:10 <Engen> cocreature: but I'm not comparing it, I'm saying let the result be evalSimple a && evalSimple b
06:10 <cocreature> oh right, then pavonia’s answer is the one you’re looking for
06:10 osa1 joined
06:10 <cocreature> you could use "PAnd a b <- p" as your guard if you really want to
06:11 takle joined
06:13 <Engen> I see...
06:13 <cocreature> regular guards need to be boolean expressions
06:13 <Engen> Oh I see my misunderstanding - I thought that doing pattern matching meant handling all your cases using guards
06:14 <cocreature> if that doesn’t work you either need to use regular pattern matching or pattern guards
06:14 <Engen> but I just need to define my function for the different use cases (which is what pattern matching actually is)
06:14 <cocreature> Engen: guards are indended when you want to check for something like "i >= 0"
06:14 <cocreature> not for differentiating between constructors
06:16 <Engen> gotcha
06:16 k0ral joined
06:17 wroathe joined
06:17 ludat joined
06:24 kylepotts joined
06:26 wei2912 joined
06:28 takle joined
06:30 kagcc joined
06:31 chessai joined
06:31 soniku joined
06:33 abhiroop joined
06:33 kirillow joined
06:34 augur joined
06:36 augur joined
06:36 takle joined
06:37 wroathe joined
06:39 LordBrain joined
06:39 steeze joined
06:39 <LordBrain> Hey, i seem to have found an infinite (non-terminating) compile using ghc7.10.3, i did it by cabal installing primitive-0.6.1.0 into a shared sandbox. IS this a known issue? I set it going 8 hours or so ago, and its still chewing on it... hovering around 70% cpu usage.
06:41 <LordBrain> could be cabal issue i dont know.. its cabal-install 1.22.9.0, with 1.22.8.0 Cabal library version
06:43 _sg joined
06:47 forgottenone joined
06:47 wroathe joined
06:48 codesoup joined
06:48 <pacak> LordBrain: ghc 7.10.3 is a bit old.
06:49 <LordBrain> yeah but so is everything else, so it shouldnt matter
06:49 <pacak> LordBrain: It's unlikely that bug will be fixed
06:49 <pacak> Unless it's reproduceable in newer versions
06:50 <LordBrain> i want to know if it is known or not, so i know what is going on
06:50 <LordBrain> if you find a trac link or something, i'd appreciate it
06:50 ArchaicLord joined
06:51 nickolay joined
06:53 fizruk joined
06:56 gibbers joined
06:56 gibbers_ joined
06:57 Itkovian joined
06:59 carlosda1 joined
07:04 Spondyl joined
07:07 wroathe joined
07:11 insitu joined
07:12 takle joined
07:14 <Engen> if I have a list defined as [(String, Bool)] and then another type Formula which contains strings that I want to replace with the Bool equivalents previously defined, would [(a,b)] -> [c] -> [c] be on the right track for lookup in hoogle?
07:15 vlatkoB joined
07:16 <Engen> actually no, it'd be [(a,b)] -> c -> c
07:17 <cocreature> I don’t think hoogle will help you directly here
07:17 <cocreature> @hoogle Eq a => a -> [(a,b)] -> Maybe b
07:17 <lambdabot> Prelude lookup :: (Eq a) => a -> [(a, b)] -> Maybe b
07:17 <lambdabot> Data.List lookup :: (Eq a) => a -> [(a, b)] -> Maybe b
07:17 <lambdabot> GHC.OldList lookup :: (Eq a) => a -> [(a, b)] -> Maybe b
07:17 <cocreature> you can use that
07:17 <pacak> My brain just exploded.
07:17 <cocreature> pacak: you might want to see a doctor in that case
07:17 <cocreature> I don’t think brains are supposed to do that
07:18 wroathe joined
07:18 iross joined
07:18 kylepotts joined
07:18 _sg joined
07:19 <Engen> cocreature: cool thanks, I think that'll get me started
07:19 magneticduck joined
07:19 takle joined
07:19 bhiliyam joined
07:22 bjz joined
07:23 swalladge joined
07:23 danthemyth joined
07:23 yellowj joined
07:28 oish joined
07:30 simukis__ joined
07:32 eyen joined
07:33 <dysfun> what's the current status of ghcjs's new code generator that makes smaller code?
07:33 <dysfun> is it at all usable yet?
07:34 <dysfun> i saw it got the dedupe option on a 6m old reddit post, but luite mentioned this new codegen in a comment and now i'm interested
07:35 splanch joined
07:35 augur joined
07:37 nepiktaz joined
07:37 abhiroop joined
07:38 splanch_ joined
07:38 wroathe joined
07:40 Destol joined
07:40 uelen joined
07:41 sanett joined
07:42 sanett left
07:43 splanch joined
07:44 windsing joined
07:45 splanch_ joined
07:46 shadowswalker joined
07:46 <shadowswalker> akslfdjalkfjdalskdjflakfjds
07:48 simukis_ joined
07:48 wroathe joined
07:49 beaky joined
07:49 xfix joined
07:49 wictory[m] joined
07:49 <shadowswalker> where to start learning haskell ?
07:50 detrumi joined
07:50 takle joined
07:51 hamishmack joined
07:51 <LordBrain> shadowswalker, install it first, then try some tutorials, i'd say
07:51 <dysfun> stack is an easy way to get started
07:52 <LordBrain> naturally it depends some on your background
07:52 <LordBrain> as to what is probably your best bet for jumping in
07:52 megaTherion joined
07:52 <LordBrain> have you programmed other languages etc
07:52 blender1 joined
07:53 m4lvin[m] joined
07:54 prooftechnique joined
07:54 <Engen> if I have something like: map (\x -> myFunction x xs) xs does the x take singular values from the list on the inside of the lambda function or from the list that it is being mapped onto?
07:55 <dysfun> x is a single item of the list at a time
07:55 dbmikus joined
07:55 <Engen> which list though
07:55 <dysfun> xs
07:55 <Engen> I guess it is cleared to see in map (\x -> myFunction x xs) xy
07:55 <Engen> xs or xy?
07:56 noraesae joined
07:56 <dysfun> xy
07:56 <pacak> there is no xs declared in second version
07:56 mjora7 joined
07:56 <dysfun> you are mapping over xy, therefore x is from xy
07:56 <pacak> (no xy either)
07:57 <Engen> yeah ok
07:57 <Engen> I'm just trying to apply the same logic for replacing elements in some from a lookup table
07:58 <Engen> s/some/some data type/
07:58 takle joined
07:58 wroathe joined
07:58 cyborg-one joined
07:59 carlosda1 joined
08:00 skeuomorf joined
08:01 _main_ joined
08:01 M-Illandan joined
08:02 <mjora7> Beginner here, should I be using Cabal?
08:02 _main_ joined
08:02 <mjora7> Or sticking to GHC and makefiles?
08:02 <dysfun> cabal makes dependencies somewhat easier
08:02 SpinTensor joined
08:02 bb010g joined
08:02 <dysfun> you may wish to consider using stack, it's a very easy way to handle projects
08:03 <dysfun> it will deal with ensuring version compatibility in dependencies
08:03 NopeMarker[m] joined
08:03 <mjora7> Ok!
08:04 <mjora7> Yeah I'm not really sure how to import libraries or anything like that at the moment. So I'll probably keep using GHC and makefiles until my textbook gets there.
08:04 <dysfun> try stack. it can generate a skeleton project and guide you on adding dependencies
08:04 <dysfun> then they're just an `import` away
08:05 <mjora7> Awesome
08:05 LordBrain joined
08:05 <mjora7> So is Stack just a newer Cabal basically?
08:05 <mjora7> Or do they solve different problems?
08:05 herzmeister[m] joined
08:05 <pacak> Cabal is a build tool.
08:05 <dysfun> no. stack uses cabal in fact
08:05 hakan[m] joined
08:05 <mjora7> Oh ok
08:06 <pacak> stack is something that supposed ensure that whenever you install something - it works.
08:06 <dysfun> stack is designed to avoid so called 'cabal hell'
08:06 <pacak> (but it more or less creates it's own hell)
08:06 <dysfun> which is where you may find some versions of libraries installed clash
08:06 <dysfun> it can be very disconcerting for a beginner
08:06 <dysfun> stack is thus an appropriate tool to start with
08:07 <dysfun> i like stack actually. i didn't at first, but it improved a lot
08:08 <mjora7> Thanks!
08:08 insitu joined
08:08 wroathe joined
08:09 raichoo joined
08:09 <mjora7> I'm using MacOS, should I be expecting any weirdness with Haskell or does it work fine on any UNIX?
08:09 <dysfun> it works fine on even windows
08:09 <mjora7> Trying to decide whether or not to switch over to my Nix machine
08:09 <mjora7> Linux*
08:09 <mjora7> Ok great
08:09 <dysfun> allegedly. i don't run it on windows so i can't say for sure
08:09 <dysfun> with stack, i should imagine your mac will be just fine
08:10 <mjora7> I guess if it's non Microsoft and works on Windows then it almost assuredly works on MacOs
08:10 reactormonk[m] joined
08:10 <dysfun> no. not really.
08:10 <dysfun> but i used to program haskell on osx with stack just fine
08:10 abhiroop joined
08:12 jer1 joined
08:15 ragepandemic joined
08:18 _sras_ joined
08:18 <mjora7> great
08:18 wroathe joined
08:19 Kreest__ joined
08:19 nilof joined
08:21 <_sras_> I cannot get the :type-at ghci command to work. What am I doing wrong? http://lpaste.net/5907372180118700032
08:22 takle joined
08:22 lep-delete joined
08:22 abhiroop joined
08:24 Maxou joined
08:24 scinawa joined
08:29 thc202 joined
08:29 wroathe joined
08:30 armyriad joined
08:31 abhiroop joined
08:31 soniku joined
08:31 <MarcelineVQ> you use the filename of your module in the module spot appearantly
08:32 sproingie joined
08:32 sproingie joined
08:33 <MarcelineVQ> e.g. :type-at Main.hs 12 1 12 3 ""
08:34 <MarcelineVQ> or more correctly :type-at Main.hs 12 1 12 3 rt once you've verified it works with ""
08:34 zachary12 joined
08:35 tommd joined
08:35 <MarcelineVQ> if you really want to be sure use an identifier that doesn't exist and it'll complain if the span is wrong and that identifier doesn't exist, :type-at Main.hs 12 1 12 3 warblegarble
08:37 newhoggy joined
08:37 nut joined
08:37 srbaker_ joined
08:39 wroathe joined
08:40 <_sras_> MarcelineVQ: ` :type-at Main.hs 12 1 12 3 asdsadfs` does not work either. It says 'Couldn't guess that module name. Does it exist?'..
08:40 <_sras_> same with 'src/Main.hs'
08:41 oisdk joined
08:42 <MarcelineVQ> Hmm then it's not loaded for some reason, try :load ing it, but try app/Main.hs first because it's not in src
08:43 abhiroop joined
08:44 Qommand0r joined
08:45 srbaker_ joined
08:45 <_sras_> MarcelineVQ: It is shown right at the prompt, "*Main> :type-at Main.hs 12 1 12 3 asdsadfs"
08:47 <MarcelineVQ> hmm, seems to work differently in a project setting, what a pain in the ass
08:47 <_sras_> MarcelineVQ: You were right. "app/Main.hs" seem to work
08:48 <MarcelineVQ> oh good, maybe not a pain in the ass hehe :>
08:49 connrs joined
08:50 wroathe joined
08:50 bvad joined
08:51 <_sras_> MarcelineVQ: So it seems that after setting +c, the module needs to be loaded by giving the path explicitly...and use the same path while querying
08:51 tomboy64 joined
08:51 <MarcelineVQ> yes seems like it. The " " should be redundant as well, should be able to write :type-at app/Main.hs 12 1 12 3 warblegarble
08:52 <MarcelineVQ> the example in the manual is :type-at X.hs 6 6 6 7 f which is where I got the idea that it wants the filename, the header is certainly more vague though :type-at ⟨module⟩ ⟨line⟩ ⟨col⟩ ⟨end-line⟩ ⟨end-col⟩ [⟨name⟩] given how people tend to use the word module
08:53 <MarcelineVQ> that and [(name)] looks like a list rather than an optional parameter, just gotta be reading these like cli commands I guessw
08:53 Maxou joined
08:54 CoderPuppy joined
08:56 JonReed joined
08:56 robotroll joined
09:00 cdidd joined
09:00 carlosda1 joined
09:05 MoALTz joined
09:09 wroathe joined
09:12 fXl joined
09:14 ania123 joined
09:15 akr[m] joined
09:16 <akr[m]> hello
09:16 <akr[m]> any tips on how to get a repl on top of a project which uses GHC 6.12 and builds with cabal-dev?
09:17 <ania123> if R is congurence relation, does f(A,B) R f(C,D) imples A R C and B R D?
09:17 grim_ joined
09:18 gehmehgeh joined
09:18 <akr[m]> I don't think so, ania123
09:19 KunoMark joined
09:20 <ania123> if \x.M R \x.N can we conclude M R N??
09:20 <ania123> akr[m]:]
09:20 <ania123> akr[m]:
09:20 bhiliyam joined
09:24 zachary12 joined
09:25 MarioBranco joined
09:25 aib joined
09:27 eyal_ joined
09:28 fXl joined
09:28 <akr[m]> I guess it depends on what exactly R is, but I see you're getting more help in ##logic
09:28 <akr[m]> (which is probably a better place for this discussion anyway)
09:29 <cocreature> akr[m]: 6.12? you really have some old projects :)
09:29 newhoggy joined
09:29 phyrex1an joined
09:30 <akr[m]> cocreature: indeed :/
09:30 featherlessbiped joined
09:30 <akr[m]> cocreature: do you think it might be a good idea to try and bump the GHC version up as much as possible?
09:31 <Taneb> ania123, not in general. 1 + 5 = 2 + 4 (and equality is most definitely a congruence relation), but 1 probably doesn't equal 2
09:31 <akr[m]> I'm not sure when exactly Applicative became a superclass of Monad
09:31 <cocreature> akr[m]: 8.0 or 7.10 I don’t quite remember
09:31 catsup joined
09:31 <cocreature> akr[m]: but getting to at least ghc 7.8 is probably a good idea
09:32 xormor joined
09:32 <cocreature> akr[m]: obviously it depends on why you want to build that project whether it makes sense to put in the effort
09:32 <Taneb> akr[m], 7.10 according to the changelog for base
09:32 <akr[m]> cocreature: do you have an estimate how many changes to the codebase would that take?
09:32 soniku joined
09:32 <akr[m]> cocreature: well they pay me for it, is that a reason good enough? :)
09:32 <cocreature> akr[m]: I guess so :)
09:32 catsup joined
09:33 sproingie joined
09:33 sproingie joined
09:33 <cocreature> akr[m]: the necessary changes heavily depend on how the code is written
09:33 <cocreature> some subsets of Haskell are relatively stable or at least the fixes are easy
09:33 <cocreature> others such as TH can require a significant amount of changes
09:34 wroathe joined
09:34 <akr[m]> it's a server backend heavily using stuff like database queries, json parsing, date/time, and also template haskell
09:34 <akr[m]> hmm
09:34 connrs joined
09:34 <cocreature> just try it and see how many compilation errors you get
09:35 sepp2k joined
09:35 <cocreature> if you still want to use the project for anything serious you are definitely going to want to upgrade it
09:36 <akr[m]> okay, I'll give it a shot then
09:36 <akr[m]> btw I hate cabal-dev
09:36 <akr[m]> just needed to tell someone
09:36 <cocreature> just don’t use it?
09:37 <akr[m]> that's the plan, yeah
09:37 <akr[m]> but the project currently uses it
09:37 kritzcreek joined
09:38 xormor joined
09:38 <cocreature> cabal-dev just manages sandboxes iirc so I don’t see how a project can depend on it
09:39 <akr[m]> well, the current build process depends on it
09:42 nepiktaz joined
09:42 abhiroop joined
09:42 mmn80 joined
09:43 fXl joined
09:44 rockfordal joined
09:44 maxirater joined
09:44 wroathe joined
09:45 <akr[m]> there are some custom-patched libraries in the project
09:45 <akr[m]> basically it's a mess
09:45 buttbutter joined
09:45 fizruk joined
09:50 splanch joined
09:52 eklavya joined
09:53 biglambda joined
09:55 wroathe joined
09:55 hackebeilchen joined
09:58 dan_f joined
09:59 hardaker joined
10:01 carlosda1 joined
10:04 drninjabatman_ joined
10:04 <drninjabatman_> hey
10:05 <drninjabatman_> Is thare a way to evaluate a type synonym to the corresponding concrete type??
10:06 cloudhead joined
10:07 netheranthem joined
10:08 <cocreature> drninjabatman_: you mean in ghci?
10:10 tapirus joined
10:10 zeroed joined
10:10 zeroed joined
10:11 <drninjabatman_> cocreature yes sorry
10:12 <akr[m]> is there any way to have `stack init` tell me more details about why it couldn't satisfy a dependency?
10:12 <akr[m]> it just says `Could not resolve dependencies: trying: HDBC-postgresql-2.3.2.0 (user goal)`
10:12 Gloomy joined
10:12 <akr[m]> but I have `HDBC-postgresql == 2.3.2.1` in my .cabal file
10:14 jer1 joined
10:14 <MarcelineVQ> could another package you require need 2.3.2.0 ?
10:14 <akr[m]> yes, but I'd like stack / cabal to tell me which :P
10:15 wroathe joined
10:15 <MarcelineVQ> are you sure it doesn't? try stack init --solver in case it can have Cabal be more specific
10:15 <cocreature> akr[m]: can you show us the full output from stack? it usually should tell you a bit more
10:16 <cocreature> drninjabatman_: :i T should show you what the type synonym expands to
10:17 <akr[m]> here it is: http://lpaste.net/354834
10:17 <cocreature> rty cabal update
10:17 <cocreature> *try
10:18 <akr[m]> same thing
10:18 <cocreature> hdbc-postgresql is not in stackage
10:18 <akr[m]> (also the warning about cabal update stays)
10:18 <akr[m]> ahh, I thought it looks in hackage as well
10:18 <cocreature> just use --omit-packages and add it to extra-deps
10:18 <cocreature> I wish there was a --force option for stack init
10:19 <MarcelineVQ> it will look in hacakge if you specify --solver
10:19 <drninjabatman_> cocreature hmm maybe I phrased the question badly: I want ghci to expand *all* type synonyms and type families in an expression.
10:19 <cocreature> I’ve never been in the situation where I didn’t had to add the packages right after I used --omit-packages
10:19 <cocreature> drninjabatman_: :kind!
10:20 <drninjabatman_> cocreature yes that worked!
10:21 <akr[m]> > :TODO: Document --solver
10:21 <lambdabot> <hint>:1:1: error: parse error on input ‘:’
10:21 <akr[m]> MarcelineVQ: what does that do?
10:21 gawen joined
10:21 sepp2k joined
10:21 <MarcelineVQ> it uses cabal to solve dependencies and adds them to your stack.yaml extra-deps section to fetch them from hackage
10:22 <MarcelineVQ> that cabal error in your paste is pretty concerning though
10:22 <akr[m]> hmm why am I getting `Invalid option `--solver'`
10:22 <MarcelineVQ> I can't tell from just that
10:22 tobhe joined
10:23 <akr[m]> this is stack 1.4.0
10:23 <cocreature> akr[m]: did you use --solver before init?
10:23 <MarcelineVQ> that's good, but I've no idea what you typed on your end when you got that error
10:23 <cocreature> stack --solver init probably doesn’t work
10:23 <cocreature> while stack init --solver should
10:23 <akr[m]> oh it goes after init, nevermind
10:23 <akr[m]> but I still get the same error :(
10:24 <MarcelineVQ> by the same you mean the cabal error?
10:24 <akr[m]> yup
10:24 <MarcelineVQ> and from the same directory you can run cabal update just fine?
10:24 <akr[m]> yeah
10:24 sepp2k joined
10:25 <MarcelineVQ> that's not fun :(
10:25 wroathe joined
10:25 <akr[m]> :(
10:25 <MarcelineVQ> try stack update
10:27 <akr[m]> oh, that helped
10:27 <akr[m]> I mean, I get a different error now :)
10:27 meck joined
10:27 <MarcelineVQ> ah alrighty, that error comes from Cabal so it doesn't know any better I guess, as far as it knows cabal update is the right thing to do
10:28 <cocreature> reporting a bug might be a good idea
10:28 Gurkenglas joined
10:28 <cocreature> at least the error message could be better
10:29 <MarcelineVQ> I would almost be good if it just automatically tried to update the index, if the index wasn't so big
10:30 <akr[m]> I'm not sure what exactly I'm to report, though
10:30 <akr[m]> thank you for the help for now, bbl lunch
10:31 abhiroop joined
10:32 rub_ixCube joined
10:33 connrs joined
10:35 RGamma joined
10:35 wroathe joined
10:36 <OnkelTem_> Hi all
10:36 grayjoc joined
10:36 <OnkelTem_> I run a program (simple snap application) using 'stack exec prog-exe'
10:37 <OnkelTem_> it binds to some port, and when I exit program by Ctrl-C in console it continues running
10:37 <OnkelTem_> Any ideas how to exit a program?
10:37 <OnkelTem_> how to terminate it easily
10:39 ziocroc joined
10:39 blender1 joined
10:40 <rub_ixCube> have you tried Ctrl-D?
10:41 hoknamahn joined
10:41 NyanPasu joined
10:42 pacak joined
10:42 Levex joined
10:42 Levex joined
10:42 eyen joined
10:43 srbaker_ joined
10:44 splanch joined
10:45 biglambda joined
10:47 Gurkenglas joined
10:47 prophile joined
10:48 wildlander joined
10:49 fizbin joined
10:49 anuxivm joined
10:49 <Gurkenglas> Might it be possible to use the same trick the platey part of lens does to derive catamorphisms for large, mutually dependent ADTs like http://lpaste.net/6928300002460565504 ?
10:50 plutoniix joined
10:50 theelous3 joined
10:51 plutoniix joined
10:56 wroathe joined
10:59 Yuras joined
10:59 hackebeilchen joined
11:00 Wizek_ joined
11:02 carlosda1 joined
11:02 Snircle joined
11:03 infy joined
11:04 detrumi joined
11:04 shainer joined
11:04 <cocreature> Gurkenglas: which trick are you referring to? iirc the platey part is just Data.Data and Data.Typeable
11:04 <cocreature> maybe a bit of Data.Generics
11:04 <cocreature> eh GHC.Generics
11:04 shainer left
11:05 fotonzade joined
11:05 <cocreature> implementing catamorphisms using generic programming techniques should be doable
11:05 dedicated joined
11:05 oish joined
11:06 <Gurkenglas> I'm like barely competent enough to use plate, have ideas like this one on when it might be usable, and that it couldn't possibly be implemented without magic somewhere along the way, not where the magic lies :P
11:06 wroathe joined
11:07 Snircle joined
11:12 JagaJaga joined
11:13 <Gurkenglas> Is there a version of template that finds occurences not of a type, but of all types that satisfy a constraint?
11:17 bertschneider joined
11:17 oish joined
11:21 bhiliyam joined
11:22 coot__ joined
11:22 electrostat joined
11:24 Guest48456 joined
11:26 blender1 joined
11:26 wroathe joined
11:26 benl23 joined
11:28 initiumdoeslinux joined
11:28 blym joined
11:29 ixxie joined
11:29 prophile joined
11:30 xall joined
11:31 connrs joined
11:31 skeuomorf joined
11:34 sproingie joined
11:34 _sg joined
11:35 newhoggy joined
11:36 tommd joined
11:37 _ashbreeze_ joined
11:37 slomo joined
11:38 yellowj joined
11:38 benl23 joined
11:43 abhiroop joined
11:45 _ashbreeze_ joined
11:45 Xanather joined
11:46 Glub joined
11:46 aglorei joined
11:46 Durbley joined
11:46 wroathe joined
11:50 crave joined
11:50 newhoggy joined
11:51 bennofs joined
11:53 oisdk joined
11:53 biglambda joined
11:54 Wuzzy joined
11:54 <KunoMark> Hmm... :-/
11:54 <KunoMark> I wonder...
11:54 <KunoMark> So, what's wrong with just leaving ApplicativeDo turned on all the time, then?
11:54 connrs joined
11:56 merijn joined
11:57 blender1 joined
11:58 <KunoMark> The biggest danger I can see is that some broken "monads" out there might chage their behaviour, since their methods are unlawful. But there doesn't appear to be a performance hit...
11:58 perubuntu joined
11:59 <MarcelineVQ> the most likely hitch is the one mentioned here https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#things-to-watch-out-for
12:00 oisdk joined
12:00 biglama joined
12:01 <lyxia> join instead of (>>=) can hit performance. For instance with lists you go through an intermediate one that might not get inlined.
12:01 _ashbreeze_ joined
12:01 <KunoMark> Yep. I saw that, MarcelineVQ. Lawless, wayward, desperado monads!
12:01 <KunoMark> Interesting lyxia. That sounds more serious...
12:02 <merijn> KunoMark: Codensity to the rescue! ;)
12:02 carlosda1 joined
12:03 <KunoMark> dafuq is dat? @merijn
12:03 blym joined
12:04 <merijn> KunoMark: Are you familiar with DList?
12:04 <merijn> @where dlist
12:04 <lambdabot> http://www.cse.unsw.edu.au/~dons/dlist.html
12:04 <merijn> Not the article I had in mind, and apparently dead
12:04 <merijn> @where + dlist http://h2.jaguarpaw.co.uk/posts/demystifying-dlist/
12:04 <lambdabot> I know nothing about +.
12:05 <KunoMark> Yep. Familiar. Cool hack to get around the performance issues of appending multiple lists. merijn
12:05 <merijn> @where+ dlist http://h2.jaguarpaw.co.uk/posts/demystifying-dlist/
12:05 <lambdabot> Done.
12:05 <merijn> KunoMark: Codensity transform is basically "DList generalised to any Monad"
12:05 <merijn> But eliminating unnecessary >>= applications, rather than ++
12:07 wroathe joined
12:07 subttle joined
12:07 zero_byte joined
12:13 <KunoMark> I'll mull over that, merijn. Sounds extremely intewresting. DLists themselves are a very cool trick (converting a potentially quadratic action into a single linear scan).
12:15 buttbutter joined
12:15 <Gurkenglas> @let data Counter a = forall self. Counter { _this :: self, _inc :: self -> self, _output :: self -> a }
12:15 <lambdabot> Defined.
12:15 <Gurkenglas> :t \(Counter a b c) (Counter d e f) -> Counter (a, d) (b &&& e) (c *** f) -- is there a way to zip these?
12:15 <lambdabot> error:
12:15 <lambdabot> • Couldn't match type ‘self’ with ‘(self, self1)’
12:15 <lambdabot> ‘self’ is a rigid type variable bound by
12:16 <merijn> KunoMark: Lemme look up the paper
12:16 t7 joined
12:17 <Gurkenglas> :t \(Counter a b c) (Counter d e f) -> Counter (a, d) (b *** e) (c *** f) -- oops, it was just a mundane misstep of mine.
12:17 <lambdabot> Counter t1 -> Counter t -> Counter (t1, t)
12:17 wroathe joined
12:17 <merijn> KunoMark: I think this is the one: https://www.cs.ox.ac.uk/ralf.hinze/Kan.pdf
12:18 connrs joined
12:19 k0ral joined
12:20 kirillow joined
12:20 <KunoMark> Excellent merijn! The paper by Janis seems to be paywalled, but I will look at the one by Ralf you just linked. :-D
12:20 RegEchse joined
12:21 <merijn> KunoMark: *cough* Sci-Hub *cough*
12:21 <merijn> Also, Google Scholar is excellent at finding free versions of papers
12:21 biglambda joined
12:23 <KunoMark> Of course I had that in mind when I said the paper is paywalled merijn! I just wanted to be PC. Hehe...
12:24 <KunoMark> " It is known
12:24 <KunoMark> that every Kan extension gives rise to a monad, the codensity monad, and
12:24 <KunoMark> furthermore that every monad is isomorphic to a codensity monad."
12:25 <KunoMark> Sounds like an amazing paper. Thanks, merijn! Cheers!
12:25 epsilonhalbe joined
12:26 subttle joined
12:27 wroathe joined
12:30 srbaker_ joined
12:31 lassulus joined
12:31 oisdk joined
12:32 <drninjabatman_> does anyone know if TypeError is in GHC 8.0.2? https://ghc.haskell.org/trac/ghc/wiki/Proposal/CustomTypeErrors
12:32 lassulus joined
12:32 <MarcelineVQ> tis
12:32 <MarcelineVQ> https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#custom-compile-time-errors
12:32 vlatkoB joined
12:33 <drninjabatman_> oh it's in typelits
12:33 <drninjabatman_> thnx MarcelineVQ
12:36 connrs joined
12:38 augur joined
12:38 pgiarrusso joined
12:39 HoierM joined
12:41 <merijn> I have a "Monad m => m a", a function "a -> a -> a" and I want basically run the action N times, combining results using said function. I'm sure there's a function like that, but I dunno where
12:41 vektorweg1 joined
12:41 eyen joined
12:42 Neomex joined
12:43 newhoggy joined
12:44 <merijn> Something like a mix of replicateM and the nonexistent iterateM
12:45 ArchaicLord joined
12:46 <tsani> merijn: foldr1 foo . replicateM n ?
12:46 be5invis joined
12:46 fXl joined
12:47 <tsani> uh, not quite
12:47 <tsani> but you get the idea
12:47 <merijn> tsani: Well, yes, except that has shitty performance :p
12:47 <tsani> ah
12:47 <OnkelTem_> Hi all :)
12:47 <OnkelTem_> A newbie has arrived
12:47 <merijn> tsani: Because it builds a large intermediate list :)
12:48 wroathe joined
12:48 <OnkelTem_> Are you folks ready for a bunch of stupid questions?
12:48 sentientsearch joined
12:48 sophiag joined
12:48 oleo joined
12:49 abel-abel joined
12:50 Guest94210 joined
12:50 cloudhead joined
12:50 AntiSpamMeta joined
12:51 <MarcelineVQ> :t \f n act -> foldr (\_ xs -> liftM2 f act xs) act [1..n-1]
12:51 <lambdabot> (Enum a, Num a, Monad m) => (a2 -> a2 -> a2) -> a -> m a2 -> m a2
12:51 <Gurkenglas> Etiquette around here has it to skip that question
12:52 newhoggy joined
12:52 meoblast001 joined
12:53 oleo joined
12:54 MarioBranco joined
12:54 <lpaste> merijn pasted “Monadic loop” at http://lpaste.net/354841
12:54 carlosda1 joined
12:54 <merijn> That's whay I came up with so far
12:55 <merijn> I'm a bit unhappy with line 3 and 7 basically being the same :\
12:55 Guest42648 joined
12:55 <Gurkenglas> :t \f n act -> foldr1 f <$> replicateM n act -- MarcelineVQ
12:55 <lambdabot> Applicative f => (b -> b -> b) -> Int -> f b -> f b
12:55 <merijn> But the only way I know how to remove that removes the tail recursion, which makes it more expensive
12:55 <merijn> replicateM is a no go, though
12:55 <merijn> That first builds the entire list
12:55 <merijn> Which is what I wanna avoid
12:56 blender1 joined
12:57 Gloomy joined
12:59 subttle joined
12:59 miklcct joined
12:59 <Gurkenglas> > runIdentity $ foldr1 (++) <$> replicateM maxBound (Identity [0]) -- are you sure? what about lazy IO?
12:59 <lambdabot> [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0...
13:00 <MarcelineVQ> which lazy IO?
13:00 <merijn> Gurkenglas: I don't see what lazy IO has to do with it?
13:00 srbaker joined
13:00 <merijn> There is no lazy IO in my example
13:00 <MarcelineVQ> you'd need a unsafeInterleaveIO in there somewhere for that, which you can't insert into replicateM's workings anyway
13:01 <MarcelineVQ> rather, it wouldn't affect how replicateM works
13:02 <OnkelTem_> How to generate an infinite list of intergers? An easy way
13:02 <Gurkenglas> > [1..] :: [Integer] -- OnkelTem_
13:02 <lambdabot> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,...
13:02 <OnkelTem_> Gurkenglas: sorry, I forgot one word: random integers
13:02 <Gurkenglas> I mean, Identity's replicateM doesn't wait for the whole list to be constructed, so it depends on the monad (say, Maybe would wait), and I thought lazy IO has to do with that
13:03 newhoggy joined
13:03 <merijn> Gurkenglas: Lazy IO is A LOT less common that people think
13:03 <merijn> Gurkenglas: base has all of 3 or so lazy IO things in it
13:03 <akr[m]> why is it that `stack solver` says that no changes are needed to `stack.yaml`, but `stack build` says that `<package> must match <version>, but the stack configuration has no specified version`
13:03 <merijn> Everything else, IO is strict
13:03 _ashbreeze_ joined
13:04 <akr[m]> I mean, I wish that the solver would add all those lines that are necessary into the yaml file
13:04 <MarcelineVQ> stack solver --update-config
13:04 <Gurkenglas> OnkelTem_, there is no uniform distribution on the Integers. Ints, maybe? getRandoms https://hackage.haskell.org/package/MonadRandom-0.1.3/docs/Control-Monad-Random-Class.html#v:getRandoms
13:05 <MarcelineVQ> though it shouldn't say no changes are neccesary if update-config would do something, so your issue may be elsewhere
13:05 <akr[m]> MarcelineVQ: I think that is the default (and does nothing for me)
13:05 <MarcelineVQ> it's not
13:05 <MarcelineVQ> but with init it is
13:05 <akr[m]> ah okay
13:05 tomphp joined
13:07 <akr[m]> http://lpaste.net/354842
13:07 <akr[m]> so should I add all those manually?
13:08 wroathe joined
13:08 <lyxia> base 4.2 O_o
13:09 <lyxia> how old is that
13:09 <Gurkenglas> merijn, why is there an argument of type (IO () -> IO a) in your code? It doesn't seem to be used
13:09 <MarcelineVQ> 7 years
13:09 <lyxia> akr[m]: what are you trying to build
13:09 <akr[m]> lyxia: uhh I didn't notice that
13:09 <akr[m]> I was going for 4.7
13:10 eyen joined
13:10 <Gurkenglas> (... could be fun if record syntax could specify fields in negative position, and then {..} eats an identifier of that name)
13:10 <akr[m]> lyxia: it's a commercial thingie that currently runs on GHC 6.2
13:11 <lyxia> Gurkenglas: Isn't that RecordWildCard
13:11 <merijn> Gurkenglas: It is used, in "work" whose definition isn't in there
13:11 <merijn> Gurkenglas: Eh, you can do that
13:12 MoALTz joined
13:12 <lyxia> akr[m]: stackage doesn't have a snapshot for such old versions of GHC so you'll have to pin packages yourself
13:12 <lyxia> akr[m]: versions of base are linked to versions of GHC
13:13 <lyxia> you can't just tell it to pick base 4.7
13:13 <MarcelineVQ> lyxia: they're trying to update to ghc 7.8, or were earlier
13:13 <lyxia> oh
13:13 <MarcelineVQ> which is where 4.7 came from
13:13 <lyxia> nevermind
13:14 mmhat joined
13:14 numee joined
13:14 <akr[m]> lyxia: yeah I know I'm going for GHC 7.8 and base 4.7
13:14 <MarcelineVQ> well that could be my misunderstanding actually, I assumed that because they were using a 7.8 resolver and you don't normally stumble into resolvers that old
13:15 <OnkelTem> Gurkenglas: how to use it? I mean I can't just create a function like g3 = getRandomRs(1, 99) as I get this: Ambiguous type variable `m0' arising from a use of `getRandomRs' prevents the constraint `(MonadRandom m0)' from being solved.
13:15 meoblast001 joined
13:15 <Gurkenglas> lyxia, I mean the dual of what RecordWildCard does - RecordWildCard makes {..} bring identifiers out of scope as provided by the record value. "could be fun" would use the value of an identifier in scope and give it to the record
13:15 Neomex_ joined
13:16 govg joined
13:16 <Gurkenglas> OnkelTem, random behavior of your code is a side effect. You can do "g3 <- getRandomRs (1,99)" as a line in the do block of your main, for example
13:17 <OnkelTem> Gurkenglas: ah, I see
13:18 <lyxia> you can build a record like let getSum = 3 in Sum {..}
13:18 <Gurkenglas> lyxia, oh, https://ocharles.org.uk/blog/posts/2014-12-04-record-wildcards.html only mentioned the other direction :)
13:19 splanch joined
13:19 nickolay joined
13:20 <lyxia> akr[m]: it seems your packages specify exact versions for dependencies
13:20 <akr[m]> lyxia: indeed
13:20 <akr[m]> I should probably remove those hard versions
13:21 <merijn> I'm still confused no one has implemented this before :\
13:22 bhiliyam joined
13:22 <Gurkenglas> OnkelTem, one reason to treat random values differently from deterministic ones is that for the latter, the compiler can tell two places far apart in time and/or space to recompute the value instead of communicating the result
13:22 Sampuka joined
13:23 <hexagoxel> :t foldr (>=>) return -- merijn does this not come close? you should be able to force the arg there.
13:23 <lambdabot> (Monad m, Foldable t) => t (c -> m c) -> c -> m c
13:24 <lyxia> akr[m]: indeed, stack will not build if it can't satisfy the dependencies as specified by the .cabal file
13:24 <hexagoxel> with replicate (i-1) (\(!x) -> ..)
13:26 <merijn> hexagoxel: Well, I'm pretty sure what I have in the paste is about as efficient as it gets. Now I want to keep it as efficient, but make it less ugly :p
13:26 <hexagoxel> merijn: although i am unsure of the exact eval order you'd end up with. but i think in the worst case it'd only evaluate the full [a -> m a], which probably is tolerable.
13:27 <merijn> hexagoxel: Honestly, I don't give a shit about the evaluation order :)
13:27 <merijn> hexagoxel: Since I'm doing the exact same monadic operation at every iteration
13:27 boombanana joined
13:28 <hexagoxel> merijn: but you do want forcing the intermediate values.
13:28 wroathe joined
13:28 <hexagoxel> :t \i m c -> m >>= foldr (>=>) return (replicate (i-1) $ \(!x) -> fmap (c x) m)
13:28 <lambdabot> Monad m => Int -> m b -> (b -> b -> b) -> m b
13:29 blender1 joined
13:29 <merijn> hexagoxel: Wait, I don't thing I understand why >=> is there?
13:29 <hexagoxel> well, really, that still is ugly.
13:29 danthemyth joined
13:30 <merijn> hexagoxel: Wouldn't that still consume quite a huge list?
13:30 <Gurkenglas> :t \n -> execWriterT . replicateM n . ?tellT -- merijn
13:30 <lambdabot> (?tellT::a1 -> WriterT w m a, Monoid w, Monad m) => Int -> a1 -> m w
13:30 <merijn> hexagoxel: Consider that i might be 10k or more
13:30 <merijn> hexagoxel: That way "foldr (>=>) return" would kinda suck
13:31 <Gurkenglas> (tellT :: m w -> WriterT w m ())
13:31 abhiroop joined
13:32 <Gurkenglas> (replicateM_, that is)
13:33 TheLemonMan joined
13:34 sproingie joined
13:34 sproingie joined
13:34 <akr[m]> ah stack build is silly, it tells me to add extra-deps at versions which don't work :(
13:35 <lyxia> "don't work" in what sense
13:36 <akr[m]> like, require newer version of base
13:36 <Gurkenglas> :t \n -> execWriterT . replicateM_ n . WriterT . fmap ((),) -- i guess saying this is less explicitly ugly than the last try
13:36 <lambdabot> (Monoid w, Monad m) => Int -> m w -> m w
13:36 <akr[m]> maybe I should fix base in my cabal
13:38 tommd joined
13:39 wroathe joined
13:41 doomlord joined
13:41 ragepanda joined
13:43 abhiroop joined
13:43 <lyxia> You should run stack build only after the versions have been figured out
13:43 obadz joined
13:43 gawen joined
13:44 albel727 joined
13:45 <ggVGc> I'm pretty glad stack exists
13:45 <ggVGc> don't know if I'd stuck with haskell dev if stack hadn't been around when I started
13:45 <ggVGc> even though it was fairly new at the time
13:45 wroathe joined
13:46 <ggVGc> tried several years earlier and got really demotivated by cabal
13:46 eyen joined
13:46 FreeBirdLjj joined
13:47 soLucien joined
13:48 Riviera_ joined
13:49 takle joined
13:49 Aruro joined
13:49 <lyxia> I hear cabal has gotten much better since then
13:53 newhoggy joined
13:53 boombanana joined
13:54 blym_ joined
13:54 Aruro_ joined
13:54 cpup joined
13:54 <lpaste> merijn pasted “How to make this less verbose?” at http://lpaste.net/354843
13:54 <merijn> Next bit where I need advice :)
13:54 <merijn> Specificall line 16-31 are soulsucking
13:56 taktoa joined
13:58 splanch joined
13:58 <Aruro> making instance of monoid?
13:59 <merijn> That doesn't really reduce the verbosity...
13:59 descender joined
13:59 <merijn> I'd still have the exact same code, just somewhere different
13:59 <Aruro> derive Monoid?
14:00 <merijn> You can't derive Monoid
14:00 <Aruro> why not?
14:01 oisdk joined
14:01 <merijn> Because it's not derivable?
14:01 <Aruro> generally if u have long names, i dont see how u can make code less verbose
14:02 <Aruro> monoid without mempty is possible to derive, i guess
14:03 <Aruro> tbh i think your code looks good
14:03 <Tuplanolla> This smells like a bifunctor, merijn.
14:04 bjz_ joined
14:05 <Aruro> why monoid is not superclass of num?
14:05 armin76 joined
14:05 <merijn> Tuplanolla: Doubt it, what makes you say that?
14:05 newhoggy joined
14:06 <Tuplanolla> I'd look for a way to `addResults = join bimap (+)` with a `instance Num Measured`, merijn.
14:07 <Tuplanolla> If not `Num`, then at least `Monoid` over `Sum`.
14:07 <merijn> Tuplanolla: Except that a Num instance for measured makes no sense? And bimap only works if you parameterise Measured (wich also makes no sense AND which makes it impossible to be strict)
14:07 <merijn> oh, wait the bimap for the tuple
14:07 FreeBirdLjj joined
14:07 <Tuplanolla> Yes.
14:08 <merijn> Tuplanolla: Anyway, bimap would limit the GHC versions this can work with
14:08 kuribas joined
14:08 eyen joined
14:09 fizruk joined
14:09 <Aruro> merijn: your code is fine, your are over optimising, how do they call it? first mistake of coding? :)
14:10 <cocreature> if you have lots of functions similar to these, you could use some generics lib.
14:10 Deide joined
14:10 <reactormonk[m]> stack clean isn't enough for `can't load .so/.DLL for ...` - ideas?
14:10 biglama joined
14:10 <cocreature> but if you use that only once it’s not worth the effort
14:11 Jafet joined
14:12 smillmorel joined
14:12 <hexagoxel> merijn: `on` removes a bit of duplication there.
14:12 <hexagoxel> (+) `on` measTime m1 m2
14:12 smillmorel left
14:13 <merijn> hexagoxel: ah, right!
14:13 sproingie joined
14:13 <merijn> cocreature: Yeah, but it never hurts to check whether someone has some clever trick somewhere :p
14:14 tomboy64 joined
14:14 <Tuplanolla> This is the reason I never finish Haskell projects...
14:14 newhoggy joined
14:15 <Aruro> i say its fault of over smart community :D
14:15 <Aruro> *ly
14:16 tommd joined
14:17 meandi joined
14:17 takle joined
14:17 <Aruro> merijn: for on u will need extra import, like Data.Function
14:17 Kenix left
14:17 <Aruro> i dont see how its better than making honest generalization and making and instance of monoid for Measure
14:18 <Aruro> Ed said make more instances, it was true.
14:18 takle joined
14:18 <lyxia> merijn: one-liner++
14:18 <Tuplanolla> You should make a monoid out of it just to call `mempty` the zero measure.
14:19 <Tuplanolla> Analysis puns are the best.
14:19 stoopkid joined
14:19 pylbrecht joined
14:19 newhoggy joined
14:20 conal joined
14:20 <lyxia> oops, one-liner doesn't have a good simple zipWith, but at least it's possible through zipWithA.
14:22 <lyxia> actually it's called binaryOp.
14:22 <lyxia> m3 = binaryOp (For :: For Num) (+) m1 m2
14:24 dfeuer joined
14:24 oisdk joined
14:26 <lpaste> merijn annotated “How to make this less verbose?” with “How to make this less verbose? (annotation)” at http://lpaste.net/354843#a354844
14:26 <Aruro> why Num is not directly subclass to monoid?
14:26 <merijn> Actually, that is a rather simple improvement :)
14:26 <merijn> Aruro: Because you can only have a single monoid instance per type, most numbers have multiple monoids
14:26 abhiroop joined
14:26 <Jafet> are StableNames always preserved over garbage collection? the haddock is nebulously vague here
14:27 <benzrf> merijn: but you could have a monoid instance for multiplication and then a wrapper for addition
14:27 <fXl> readX :: IO (Maybe DataX) , how can i make patter matching on this ? i did readerX :: Maybe DataX -> String ; (Just a) -> a , it fails.
14:28 <merijn> Jafet: What do you mean "preserved over garbage collection"
14:28 <Aruro> yes but there are no default instances of monoid for Num
14:28 <Aruro> why not making it at least plus
14:28 newhoggy joined
14:28 <Aruro> if u want Prod u add Data.Monoid
14:29 <Aruro> otherwise deafult is Sum , mappend 1 2 == 3
14:29 <Jafet> merijn: will makeStableName, on the same object, always return the same name?
14:29 blender1 joined
14:30 <merijn> Jafet: Yes
14:30 <merijn> Jafet: Actually, maybe
14:30 <cocreature> I don’t think so. the same itself stays stable but creating a new name for the same object does not have to be stable afaik
14:31 <Jafet> (let's assume it's already in NF so that the object won't be changed by evaluation)
14:31 <merijn> "The reverse is not necessarily true: if two stable names are not equal, then the objects they name may still be equal. Note in particular that mkStableName may return a different StableName after an object is evaluated."
14:32 Itkovian joined
14:33 <Aruro> fXl: readX >>= \x -> case x of Just a -> .. ?
14:34 <Jafet> it just seems nebulously vague for the documentation to not guarantee anything at all under any circumstances
14:35 <merijn> Jafet: Still better than reallyUnsafePtrEquality# :p
14:35 Gurkenglas joined
14:35 <merijn> At least StableName guarantees no false positives...
14:36 <fXl> Aruro, http://lpaste.net/354845
14:36 spatial joined
14:37 <fXl> Aruro, actually this one , http://lpaste.net/354845
14:37 <spatial> Which library should I use to get a random values from a uniform distribution of n values ?
14:38 xall joined
14:39 <akr[m]> sorry I lost my connection
14:39 shafox joined
14:39 <spatial> hmatrix has it. How is it used ?
14:39 <akr[m]> lyxia: how do I know that the versions have been figured out?
14:39 <cocreature> :t randomR
14:39 newhoggy joined
14:39 <lambdabot> (RandomGen g, Random a) => (a, a) -> g -> (a, g)
14:39 <cocreature> ^ spatial
14:39 <merijn> cocreature: Does Random guarantees uniform distribution?
14:39 <merijn> Or rather, is that a law?
14:39 <cocreature> merijn: at least the docs claim it does
14:40 <cocreature> “Takes a range (lo,hi) and a random number generator g, and returns a random value uniformly distributed in the closed interval [lo,hi], together with a new generator.”
14:40 systemfault joined
14:40 <Jafet> does Random even define what random is
14:40 <shafox> Is it difficult to code a Graph Database in Haskell ? I read couple of blogs but couldnt determine whether it is correct or not.
14:40 <merijn> shafox: Well, yes, but then coding a Graph Database is difficult in any language
14:41 <lyxia> akr[m]: have you tried stack solver --update-config after relaxing your constraints
14:41 SlashLife joined
14:41 <Aruro> fXl: u can not put string in case of Nothing , it should be some value of type DataX, otherwise all fine
14:41 <lyxia> akr[m]: and after removing any extra-deps that were there, unless you are positive some versions are right
14:42 <fXl> what should i put ? :D secondly this fails i am stuck
14:42 <lpaste> Gurkenglas annotated “How to make this less verbose?” with “How to make this less verbose? (annotation) (annotation) @merijn, plated with lens” at http://lpaste.net/354843#a354847
14:42 <akr[m]> lyxia: so stack init --solver put about 20 packages into extra-deps
14:42 <shafox> merijn: Yes I understand that, but I am asking particularly for Haskell, As seen in Github all the databases written in OOP languages such as Java (heavily). Is there any particular reason for the same or its just nobody has done it fully ?
14:43 <akr[m]> lyxia: and stack solver doesn't see anything wrong with the config, it says that the build plan succeeded
14:43 <Aruro> fXl: i dont know what is DataX depends on your code, post whole program, otherwise unclear
14:43 <lyxia> akr[m]: odd
14:43 <fXl> how can i use readerX to readX
14:43 <spatial> cocreature: Which function is that ?
14:43 <akr[m]> lyxia: but stack build suddenly figures out that there are missing packages in extra-deps
14:43 <Aruro> fXl: inside main
14:43 <cocreature> spatial: the one that I showed you
14:43 <Gurkenglas> Is there a version of template that finds occurences not of a type, but of all types that satisfy a constraint?
14:43 <merijn> shafox: Well, some HPC things are tricky to do in Haskell, especially if you're not very experienced in Haskell. But overall, it shouldn't be THAT much harder. Especially since there's an easy FFI
14:43 <fXl> i have something else there, like program menu
14:43 Neomex joined
14:44 soniku joined
14:44 nickolay joined
14:44 <Gurkenglas> merijn, are the WriterT/template suggestions adequate?
14:44 <lyxia> akr[m]: That doesn't sound normal, but I'm not sure what you can do about this :/
14:44 <akr[m]> lyxia: missing in the sense that stack build complains that a bunch of additional packages need to be specified in extra-deps
14:45 hc joined
14:46 <merijn> Gurkenglas: Elegant, but not something I can realistically use, since I don't think adding a lens dependency will be accepted :)
14:46 <akr[m]> lyxia: oh and stack build then tells me to add these missing packages to extra-deps, but the versions it selects are in conflict base == 4.7.*
14:46 <akr[m]> in conflict with*
14:47 <akr[m]> can I fix base version in stack.yaml somehow or something
14:47 <* hvr> can't help but wonder if using cabal instead of stack wouldn't be easier for akr[m]
14:47 wroathe joined
14:47 splanch joined
14:47 <akr[m]> possibly, I should try
14:48 <hvr> akr[m]: is the project you're trying to build public somewhere?
14:48 <akr[m]> but it's annoying, stack at least sets up the correct version of GHC for me…
14:48 <akr[m]> hvr: afraid not
14:48 raichoo joined
14:48 <lyxia> akr[m]: can you paste your stack.yaml
14:48 newhoggy joined
14:48 <hvr> akr[m]: what OS are you one?
14:48 <hvr> akr[m]: what OS are you on?
14:48 <lyxia> and maybe the dependencies
14:48 <Aruro> correct version of ghc, sounds interesting
14:49 oisdk joined
14:49 <akr[m]> hvr: GNU/Linux
14:49 <akr[m]> here;s stack.yaml: http://lpaste.net/3036490076671442944
14:50 <lyxia> ghc-7.8 is that legal
14:50 <hvr> akr[m]: fwiw, at least on Debian/Ubuntu, setting up the "correct" GHC is just a matter of a simple `apt install` (after having done the one-time setup of adding the apt repo)
14:51 <merijn> hvr: Even installing the binary distro is fairly trivial
14:51 <hvr> true dat
14:51 <fXl> Aruro, https://hastebin.com/akomagobil.hs , whole is here
14:51 <akr[m]> lyxia: why not?
14:51 thatguy joined
14:51 halogenandtoast joined
14:51 m0cesta joined
14:52 <fXl> Aruro, if you can't see hpaste, here lpaste http://lpaste.net/354849
14:52 <lyxia> akr[m]: because GHC versions are 7.8.1, 7.8.2, 7.8.3, 7.8.4
14:52 <Aruro> fXl: add stuff in main, after pring
14:52 <akr[m]> hmm, well `stack --resolver ghc-7.8` didn't complain
14:52 zeroed joined
14:53 soLucien joined
14:53 noddy joined
14:53 descender joined
14:53 <lyxia> Okay, I guess it works
14:54 newhoggy joined
14:54 <fXl> Aruro, sx a = do ; f <- readConfig ; return (readConfigX f), this says no instance for show :D
14:54 bennofs1 joined
14:55 <Gurkenglas> merijn, can I see the codebase to see if I can spot some more tricks? (just https://github.com/merijn/criterion ?)
14:56 _101010 joined
14:56 acarrico joined
14:56 <Aruro> fXl: main = readConfig >>= (print . readConfigX)
14:56 <Aruro> fXl: for Nothing case put undefined, otherwise will not compile
14:57 <_101010> Hey guys, quick question, what is the difference, if any between:
14:57 <_101010> sum' :: Num a => [a] -> a
14:57 <_101010> and sum' :: (Num a) => [a] -> a
14:57 <_101010> in terms of type signature
14:57 <mauke> none
14:57 <_101010> so what's the point of parentheses? just readibility?
14:57 <_101010> in this particular case
14:58 <mauke> :t sum :: (((Num a))) => (([(a)]) -> (a))
14:58 <lambdabot> Num a => [a] -> a
14:58 <Aruro> fXl: or main = a<-readConfig; print (readConfigX a) -- u have to format
14:58 <merijn> Gurkenglas: That one, yes, but I haven't committed/pushed these changes yet :)
14:58 <fXl> Aruro, i am so confused, why i can't do it
14:58 <fXl> :S
14:58 Jonas22 joined
14:59 <Aruro> did u try what i suggested?
14:59 <merijn> _101010: The parens are mandatory if you have more than one class, i.e. "(Eq a, Enum a) => ..." so some people always add them for consistency
14:59 jmcarthur joined
14:59 <fXl> Yes, it worked
14:59 <lyxia> akr[m]: can you show the current stack build
14:59 <lyxia> akr[m]: I mean, what it outputs
14:59 ralu joined
15:00 <Eduard_Munteanu> Actually if you have more or less than one class.
15:00 <Aruro> fX1 : it will crash if file can not be read and u hit Nothing branch
15:00 <Jonas22> If im having difficulties with a task, do i just ask here or is there a volunteer to pm? :-) [beginner]
15:00 <Eduard_Munteanu> :t x :: () => [a] -> a
15:00 <fXl> what i want to do is, just take those Strings and put them in somewhere else and use in another function. why i have to use main for that ?
15:00 <lambdabot> error:
15:00 <lambdabot> • Couldn't match expected type ‘[a1] -> a1’ with actual type ‘Expr’
15:00 <lambdabot> • In the expression: x :: [a] -> a
15:00 <_101010> merijin, got it, thanks :)
15:00 <lyxia> Jonas22: just ask
15:00 <fXl> Aruro, what i want to do is, just take those Strings and put them in somewhere else and use in another function. why i have to use main for that ?
15:00 <Aruro> fXl: u can write it in your own function, but running only possible in main
15:01 <fXl> this shouldnt be this much hard, i should be idiot
15:01 Neomex_ joined
15:01 <Aruro> myFun = readConfig >>= (mystuff . readConfigX)
15:01 <akr[m]> lyxia: http://lpaste.net/354850
15:01 <Aruro> fXl: your function will have type IO because readConfig has IO
15:02 jtaylor100 joined
15:02 <fXl> i want those strings not IO , IO is too hard for me too figure out :D
15:02 godfreygyz joined
15:02 <Aruro> u can write function on IO, but eventually they need to be run in main
15:03 <fXl> Aruro, btw i want to ask you something, what if i want to read another Data, i have to do IO for every yaml data ? like readConfig ?
15:03 butterthebuddha joined
15:03 <c_wraith> Whenever possible, you should avoid IO in your types.
15:03 beerdrop joined
15:03 <Aruro> fXl: yes every file operation is IO u can stuck all in main function, for starters
15:04 newhoggy joined
15:04 <Aruro> fXl: just make program working, u will understand step by step
15:04 <fXl> Aruro, yeap it works finally ty
15:05 <Jonas22> okay, problem being: i am given a matrix (NOT in list form and i am not allowed to use list syntax in this task), but like this: field 1 1 = 0, field 1 2 = 1, field 2 2 = 0 and so on. My task is to implement a function which takes the field and the x and y coordinate as arguments (like this: myFunctionfieldA 1 2) and always returns a zero, as in "r
15:05 <Jonas22> eplacing whatever number was there before". I've gotten a hint that an anonymous function would work well for that. Any advice?
15:05 <fXl> Haskell is too complicated for me :D i can't do anything :S
15:06 ragepanda joined
15:06 <c_wraith> Jonas22: so the matrix representation you're given is like (Int -> Int -> Int)?
15:06 vijayender joined
15:07 <Jonas22> yes
15:07 <Jonas22> its basically meant as a playfield, with certain positions having players (-> numbers) on it.
15:08 <c_wraith> Jonas22: so what's the type of the update function?
15:08 <fXl> Aruro, Just b -> b , b is Pointer {point = "/home/user/file"}, how can i take that /home/user/file from there now on ?
15:08 <c_wraith> Jonas22: it's always best to start with the types. Especially when they're kind of hairy, like this case. :)
15:08 <Jonas22> I've tried https://thepasteb.in/p/P1hvWXwpMw8tl
15:09 <c_wraith> Jonas22: but what's the type?
15:09 <Jonas22> Unfortunately i dont know which type you're refering to.
15:09 vijayender joined
15:09 <c_wraith> what is the type of mark?
15:09 newhoggy joined
15:10 <Jonas22> well mark is supposed to be a function, which replaces given position with a zero
15:10 <Jonas22> as in "marking that spot"
15:10 <mauke> no, what is the type?
15:10 <c_wraith> Not "what does it do"... what is its type?
15:10 vijayender joined
15:11 <Jonas22> sorry, i dont get it :-(
15:11 insitu joined
15:11 tommd joined
15:11 <mauke> get what?
15:11 <Jonas22> the type of a function?
15:11 <c_wraith> So, you've got the start.. It's a function. Work from there. What are its arguments? What does it return?
15:12 <Jonas22> ah
15:12 <Aruro> fXl: point b
15:12 skeuomorf joined
15:12 <Aruro> fXl: its called record syntax
15:12 butterthebuddha joined
15:12 <mauke> the type of a function is written A -> B where A is the type of the argument and B is the type of the result
15:12 <Jonas22> yes, i tried giving in a signature, my idea would be: Int -> Int -> String, but that turned out to be wrong.
15:13 <Jonas22> Int -> Int because of the coordinates, which come first
15:13 <Jonas22> and since its supposed to work like mark x y f (f being a field like field1 1 2 = 3) i thought the third parameter is supposed to be a stringf
15:13 <c_wraith> Jonas22: well, Int -> Int -> something
15:14 <mauke> well, it should be something like Int -> Int -> Field -> Field
15:14 <mauke> where Field is the type of your field
15:14 <Jonas22> oh!
15:14 <mauke> I don't see where you're getting string from, though
15:14 <c_wraith> Field is apparently a type synonym for Int -> Int -> Int
15:14 <fXl> Aruro, the error, Variable not in scope: point :: Pointer -> String , Perhaps you meant data constructor ‘Pointer’ (line 22)
15:14 <mauke> c_wraith: spoilers!
15:14 <Jonas22> I think i got something. The fields dont have any signatures ot all. Even before the change.
15:15 fizbin joined
15:15 <Jonas22> and yes, field is indeed Int -> Int -> Int
15:15 <lyxia> akr[m]: and these missing dependencies are in the .cabal file?
15:15 <fXl> Aruro, i did Just b -> point b, the error, Variable not in scope: point :: Pointer -> String , Perhaps you meant data constructor ‘Pointer’ (line 22)
15:16 shafox joined
15:16 <Jonas22> thanks everyone, ill try for myself a little bit - you ignited a spark, very helpful, thank you :-)
15:16 <akr[m]> lyxia: yes, or at least some of them. Some of them are dependencies of dependencies, I think
15:16 <akr[m]> #dependencyhell
15:17 butterthebuddha joined
15:17 <lyxia> akr[m]: do you have to use a ghc resolver rather than lts-2.22
15:17 sepp2k joined
15:17 <akr[m]> lyxia: this is code that compiles on GHC 6.something
15:18 <akr[m]> I have a feeling trying to move it to 8.* would be rather painful
15:18 <spatial> randomR size (mkStdGen 66) How is size given ? (1,size) ?
15:18 <lyxia> akr[m]: lts-2.22 is a snapshot for ghc 7.8.4
15:18 <akr[m]> not sure even about 7.8, I wanted to see how many compilation errors I'd be getting, lyxia
15:18 <akr[m]> ah
15:18 zeroed joined
15:19 <lyxia> it contains most (all?) of the packages listed in your extra-deps and the things that should have been there. The problem you are having is still puzzling however.
15:20 hackebeilchen1 joined
15:20 <akr[m]> I'll try with that lts version
15:20 <lyxia> akr[m]: can you share your cabal file too
15:21 newhoggy joined
15:22 <akr[m]> lyxia: I'll pm it to you
15:22 bhiliyam joined
15:24 sentientsearch joined
15:25 frankpf joined
15:25 dejanr joined
15:26 bennofs joined
15:27 <Jonas22> Hi, me again. I've created a pastebin to better visualize the problem i'm having. I guess its simple, but i just cant get the hang of it. Any advice is greatly appreciated! https://pastebin.com/gMAx693b
15:28 codesoup joined
15:28 <mauke> Jonas22: what is (\f k -> f 0) f (f x y) supposed to do?
15:28 Levex joined
15:29 <Jonas22> in the original task it said that a anonymous function might be useful for this. Thats what i tried, but terribly failed at.
15:29 <butterthebuddha> Hey peeps
15:29 iomonad joined
15:30 <butterthebuddha> I have an array of strings and I wanna cast 2 of those into integers
15:30 <Jonas22> It was supposed to "overwrite the result only, which is (i guess) not possible in haskell. f stands for playfield and k is the result
15:30 <butterthebuddha> I have already have one "where" clause in my function and turns out you can't have more than one
15:30 <mauke> Jonas22: no, in your code f is bound to f and k is bound to f x y
15:30 <mauke> Jonas22: so the whole thing reduces to f 0
15:30 <butterthebuddha> How do I cast those values and get the result in a form I can use in the function?
15:30 <mauke> (k is unused)
15:31 <mauke> butterthebuddha: there are no casts in haskell, and you can as many bindings as you want in a where clause
15:31 <mauke> *can have
15:31 <butterthebuddha> mauke I believe there is a function that goes from String -> Integer called "read"?
15:31 <mauke> yes
15:32 <Jonas22> mauke yes, and f x y (playfield A 1 2) being reduced to 0 would work, so i hoped.
15:32 <Jonas22> (*playfieldA)
15:32 {emptyset} joined
15:33 psychicist__ joined
15:33 <mauke> er, what?
15:33 newhoggy joined
15:33 <mauke> let's say you're calling markSpot 1 2 playfieldA
15:34 <mauke> then your code tries to return playfieldA 0
15:34 <mauke> that makes no sense
15:34 danthemyth joined
15:34 <Jonas22> you are right. i get that part now.
15:34 <Jonas22> Is there another way to go about it?
15:35 <mauke> you can derive sort of a skeleton of the code from the type
15:35 <mauke> markSpot x y f = ... -- you've already got this part
15:35 <mauke> with x :: Int, y :: Int, f :: Int -> Int -> Int
15:35 Neomex joined
15:35 <mauke> now what you need to return is of type Int -> Int -> Int
15:35 abhiroop joined
15:35 <fXl> Aruro, thanks for your time, appreciated
15:35 splanch joined
15:36 <mauke> that's a function. so what's the syntax for a function?
15:36 shafox joined
15:36 stef204 joined
15:37 <Jonas22> markspot :: Int -> Int -> (Int -> Int -> Int) -> (Int -> Int -> Int)
15:37 <Jonas22> inst that how its supposed to go?
15:38 <mauke> ... yes? worauf willst du hinaus?
15:38 <c_wraith> Jonas22: that looks like the right type
15:38 grayjoc joined
15:38 caumeslasal joined
15:39 gugah joined
15:39 blender1 joined
15:39 gugah joined
15:41 <butterthebuddha> So if if have a list like ["random str 0", "random str 1", "random str 2", ...]
15:41 <butterthebuddha> How do I get all the values from "random str 2" till the end as a space delimited string
15:41 newhoggy joined
15:41 <butterthebuddha> So something like "random str 2 random str 3...random str n"
15:41 <c_wraith> butterthebuddha: break it into pieces. First, get strings you want. Second, combine them.
15:42 Neomex joined
15:42 <cocreature> dropWhile will help with the first part
15:42 <cocreature> intercalate helps with the second
15:42 <hexagoxel> (or unwords in this case)
15:45 <rotaerk> hmm I'm currently planning to use 0MQ for inter-process communication, using cereal to encode/decode haskell data types. I also need to do some inter-thread communication, and I can do it the same way, but it just seems silly to be serializing/deserializing when it's never going to escape the same haskell process
15:45 <rotaerk> is there a more appropriate library for inter-thread message-passing in haskell
15:46 conal joined
15:46 Deide joined
15:46 <butterthebuddha> cocreature: dropWhile is similer to filter in python from what I understand; how is that useful?
15:46 <cocreature> rotaerk: you can just use Control.Concurrent.Chan
15:46 <geekosaur> TChan?
15:46 <geekosaur> or just Chan
15:46 <rotaerk> thanks
15:47 <geekosaur> butterthebuddha, dropWhile and filter are different things
15:47 <cocreature> > dropWhile (/= "random str 2") ["random str 0", "random str 2", "random str 3"] -- butterthebuddha
15:47 <geekosaur> although I think just drop here, not dropWhile
15:47 <lambdabot> ["random str 2","random str 3"]
15:47 shafox joined
15:47 <geekosaur> (I took what you said to be positional, not string value)
15:48 <butterthebuddha> Ah, the literal strings I wanna join can be anything
15:48 <butterthebuddha> Not just "random string 2", "random str 3"
15:48 trism joined
15:48 <butterthebuddha> Anyways, I ended up just using tail
15:50 binaryplease joined
15:50 bvad joined
15:50 electrostat joined
15:54 maarhart joined
15:54 <butterthebuddha> I was hoping for a "style analysis" of this code: https://gist.github.com/awesomeaniruddh/40ae0fbb5610b2cd9ad9bb72fc958294 (it's not a lot of code, just 18 lines); it's a solution to the first problem here: https://www.seas.upenn.edu/~cis194/spring13/hw/02-ADTs.pdf
15:56 hoknamahn joined
15:56 marcopullo joined
15:57 newhoggy joined
16:00 blym_ joined
16:02 conal joined
16:04 urodna joined
16:04 DemiMarie joined
16:06 halogenandtoast joined
16:07 shafox joined
16:07 halogenandtoast joined
16:08 newhoggy joined
16:10 <glguy> butterthebuddha: I'd prefer to see pattern matching to access the 1st, 2nd, and rest of the elements in the list
16:10 texasmynsted joined
16:10 <glguy> or I'd expect to there to be some other justification for using !! and tail like a length check or an invariant of the function that returned the list
16:10 cobreadmonster joined
16:10 marcopullo joined
16:11 maarhart joined
16:11 blym joined
16:12 meandi_2 joined
16:12 epsilonhalbe joined
16:13 bertschneider joined
16:14 <spatial> http://lpaste.net/354857 There is parse error at the first statement after case
16:14 <spatial> n < Q = do
16:15 <glguy> spatial: case match clauses expect patterns, not boolean expressions
16:15 <glguy> and you build those match clauses like: 'PATTERN -> EXPRESSION', rather than with an =
16:15 <glguy> It looks like you want: if n < Q then .... else ....
16:16 <glguy> Next, you don't need so many lets, you can just use one
16:16 <glguy> Next, you can't use a where like that
16:16 <glguy> where is associated with the definition of runsimulations, it is outside the scope of all of those let expressions
16:16 newhoggy joined
16:16 <glguy> so for example 'N' is not in scope in the where clause
16:16 <spatial> Let me iterate
16:17 <spatial> case cannot be used here at all ?
16:17 <spatial> 0 and > 0
16:17 windsing joined
16:17 <glguy> Right, those aren't patterns, that's not what case is for
16:17 marcopullo joined
16:17 <monochrom> Guards will do that nicely.
16:18 shafox joined
16:18 <glguy> Patterns are variables, and constructors applied to zero or more patterns
16:18 <monochrom> You cannot just go "in English 'case' means ___" and hope it extends to Haskell.
16:19 <monochrom> Or "I saw math proofs that use 'case' like this" for that matter.
16:19 jason85 joined
16:19 <geekosaur> pascal, c (switch/case), etc. --- it's understandable
16:20 <geekosaur> it's just wrong, case means pattern matchiong on structure in Haskell
16:20 fotonzade joined
16:21 sentientsearch joined
16:22 mac10688 joined
16:23 <hpc> i don't even want to know how "in english $keyword means _" would translate to bash
16:24 <monochrom> "if" translates pretty well. But "fi" will not mean "like wifi but with wire" :)
16:24 abhiroop joined
16:25 newhoggy joined
16:25 marcopullo joined
16:25 <mauke> esac
16:25 <EvanR> wirefull
16:26 Tesseraction_c joined
16:26 <geekosaur> should called it logla >.>
16:27 srbaker joined
16:28 abel-abel joined
16:29 kirillow joined
16:29 tobhe joined
16:30 blym_ joined
16:31 takle joined
16:32 bennofs1 joined
16:33 augur joined
16:33 epsilonhalbe left
16:34 marcopullo joined
16:35 hackebeilchen joined
16:35 dedicated joined
16:35 NikolajK joined
16:35 godfrey joined
16:36 flatmap13 joined
16:37 shafox joined
16:38 JuanDaugherty joined
16:39 xenog joined
16:40 blender1 joined
16:41 newhoggy joined
16:41 grayjoc joined
16:42 augur_ joined
16:43 m0rphism joined
16:44 Maxou joined
16:44 Lu joined
16:44 <EvanR> wow... Data.Colour is intense
16:46 blym joined
16:46 sleffy joined
16:46 MoALTz_ joined
16:47 <EvanR> i had a feeling computer color was complicated and no one was doing it right, but i didnt know someone else was thinking the same thing. i guess thats haskell for you
16:47 ublubu joined
16:47 nut joined
16:48 newhoggy joined
16:48 <JuanDaugherty> it works in 8?
16:49 insitu joined
16:49 <kuribas> EvanR: add to that calibration of monitors...
16:49 <rotaerk> if only they'd spelled color the proper way
16:50 freeside joined
16:50 shafox joined
16:51 <JuanDaugherty> people in that lil island still think they own the english
16:52 conal joined
16:52 c_my_nick joined
16:52 <EvanR> GHC is british so
16:52 <EvanR> ive come to expect it
16:53 <c_wraith> isn't Glasgow in Scotland?
16:53 <JuanDaugherty> well it may not be in the UK for long
16:53 <* EvanR> checks the latest on british organization
16:53 <c_wraith> Oh, that is British. But not English.
16:53 connrs joined
16:53 <EvanR> yeah its not obvious that scotland is still british, from what i heard
16:53 <JuanDaugherty> yeah the whole archipelago or whatever is britain
16:53 <c_wraith> It's still on the island of Britania
16:54 leolein joined
16:54 <EvanR> its still the worse part of ultima online
16:54 newhoggy joined
16:55 jimmyrcom joined
16:55 mizu_no_oto joined
16:55 xenog joined
16:55 <EvanR> it really is interesting how little america is to blame for ML, haskell, stuff
16:55 <EvanR> were still stuck in lisp
16:55 <JuanDaugherty> little america? you mean the super continent?
16:56 <EvanR> americuh
16:56 <JuanDaugherty> when the UK was coming up China was the only continental size power
16:56 <JuanDaugherty> as a nation state anyway
16:56 <glguy> Seems like this has diverged from the topic
16:56 Wizek joined
16:57 <JuanDaugherty> the end thing apparently will be little england if scotland joins the EU
16:57 <JuanDaugherty> uh, remains in the EU
16:57 <JuanDaugherty> oh sorry thought i was in off-topic
16:57 <mauke> btw, I was able to help out Jonas22 in /msg (and in German)
16:58 <c_my_nick> i am using attoparsec and have a function with a return type of `State ParserState (Parser r)`. the function is supposed to parse some stuff, append the results of the parser to the state, and then return the results inside the Parser monad.
16:58 <c_my_nick> how do i get the result back into the Parser monad? http://lpaste.net/354860
16:58 augur joined
17:00 <EvanR> is there a #haskell-de
17:01 <JuanDaugherty> are you in fact using Data.Colour in 8 without doing anything other than importing it from hackage?
17:01 <EvanR> ghc 8 ?
17:01 <JuanDaugherty> yes
17:01 <EvanR> i still have 7.10
17:01 <JuanDaugherty> ty
17:02 chrissl joined
17:02 sproingie joined
17:02 ejay joined
17:04 fizruk joined
17:05 <JuanDaugherty> and there is a #haskell-de oder
17:05 <xenog> I'm writing a concurrency library and I would like to add generic TCP client and server to it. It seems that Data.Conduit.Network from conduit-extra is the way to go. Is there anything else?
17:05 newhoggy joined
17:06 <* JuanDaugherty> slams the door on the hurt locker on the way out.
17:06 JuanDaugherty left
17:06 mizu_no_oto_work joined
17:06 splanch joined
17:07 insitu joined
17:10 butterthebuddha joined
17:10 AndreasK joined
17:11 ChaiTRex joined
17:11 tomphp joined
17:11 newhoggy joined
17:12 xall joined
17:12 butterthebuddha joined
17:12 augur_ joined
17:13 shafox joined
17:14 abhiroop joined
17:16 augur joined
17:16 bennofs joined
17:16 Xanather joined
17:20 newhoggy joined
17:20 khumba joined
17:21 caumeslasal joined
17:22 eklavya joined
17:22 raichoo joined
17:22 NikolajK joined
17:23 bhiliyam joined
17:24 shafox joined
17:24 wroathe joined
17:27 <hexagoxel> es ist #haskell.de, aber auch da ziemlich leer.
17:30 insitu joined
17:31 moth joined
17:31 ArchaicLord joined
17:31 newhoggy joined
17:31 <alx741> /join #haskell.es
17:31 <alx741> oops, sorry
17:32 <alx741> hexagoxel: so is every other #haskell.something
17:32 maxirater joined
17:32 xenog joined
17:34 windsing joined
17:34 jmnoz joined
17:34 MarioBranco joined
17:35 bvad joined
17:36 sssilver joined
17:36 sleffy joined
17:36 soniku joined
17:37 SlashLife joined
17:37 FreeBirdLjj joined
17:38 wroathe joined
17:39 splanch joined
17:40 dan_f joined
17:41 blender1 joined
17:41 acertain joined
17:42 oish joined
17:43 jzelinskie joined
17:43 shafox joined
17:44 newhoggy joined
17:47 xcbot joined
17:47 <xcbot> 7¶Ô10´ó¼Ò7˵:12,0 £¿ 
17:47 <* xcbot> afcondon_ ¤ª¤Ï¤è¤¦
17:48 <* Clint> squints.
17:48 Gloomy joined
17:49 <geekosaur> could the bot testing take place elsewhere please?
17:49 <geekosaur> you can create your own one-off channels just by joining them
17:49 <geekosaur> (also you appear to have an encoding problem)
17:50 danthemyth joined
17:50 Majiir joined
17:51 TheLemonMan joined
17:52 wingwalker joined
17:52 newhoggy joined
17:52 jmnoz_ joined
17:52 tomphp joined
17:53 connrs joined
17:53 tomphp_ joined
17:54 shafox joined
17:55 eklavya joined
17:55 NeverDie_ joined
17:57 Itkovian joined
17:59 Jesin joined
17:59 Gurkenglas joined
18:00 Neomex joined
18:00 ragepandemic joined
18:01 snowalpaca joined
18:02 robotroll joined
18:05 zeroed joined
18:05 zeroed joined
18:05 newhoggy joined
18:06 gugah joined
18:06 zero_byte joined
18:10 Itkovian joined
18:11 bollu joined
18:14 abhiroop joined
18:14 arctictern joined
18:14 shafox joined
18:14 windsing joined
18:17 Guest48456 joined
18:18 newhoggy joined
18:19 mizu_no_oto_work joined
18:21 ublubu joined
18:21 caumeslasal joined
18:22 Maxou joined
18:22 wroathe joined
18:22 sgflt joined
18:23 ixxie joined
18:23 <ertes> glguy: could you tell me which haddock command you used to generate hackage-compatible docs?
18:24 <ertes> i have used this one so far: ./Setup haddock --contents-location='/package/$$pkg-$$version' --hoogle --html --html-location='/package/\$$pkg-\$$version/docs' --hyperlink-source
18:24 newhoggy joined
18:24 fizruk joined
18:24 augur joined
18:25 <glguy> ertes: Here's my script https://github.com/ekmett/lens/blob/master/scripts/hackage-docs.sh
18:25 <cocreature> ertes: maybe take a look at what cabal haddock --for-hackage does
18:25 <glguy> and apparently I committed some local openssl nonsense
18:25 eliasr joined
18:25 <ertes> oh, --for-hackage, nice
18:25 <ertes> thanks
18:26 ralu joined
18:27 <glguy> The script used to be more complicated before cabal-install added --for-hackage
18:27 <ertes> yeah, cabal has that flag, too
18:27 abhiroop joined
18:27 butterthebuddha joined
18:28 <ertes> is there a reason you used --haddock-option=--hyperlinked-source instead of --hyperlink-source?
18:30 shafox joined
18:30 LHoT10820 joined
18:31 tomphp joined
18:31 <cocreature> ertes: the former is the new fancy syntax highlighting added in haddock 2.17 iirc
18:32 newhoggy joined
18:33 <ertes> ah
18:33 wroathe joined
18:33 safe joined
18:33 ckubrak joined
18:34 a3Dman joined
18:35 <ertes> hmm, cabal doesn't automatically generate the tar.gz as it seems
18:35 <cocreature> it did for me the last time I tried it which was a few weeks ago
18:35 <cocreature> so I’d be surprised if anything changed :)
18:35 <ertes> maybe i'm doing something wrong
18:36 mizu_no_oto_work joined
18:36 <cocreature> what’s the exact command you’re running?
18:36 maxirater joined
18:36 <ertes> docs: dist/setup-config Setup default.nix shell.nix
18:36 <ertes> $(nixsh) "./Setup haddock --for-hackage --haddock-option=--hyperlinked-source"
18:36 <cocreature> so you’re not using cabal?
18:36 <ertes> well, not cabal-install
18:36 Wuzzy joined
18:36 <ertes> i can't assume that it's available in the environment nix' ghcWithPackages generates
18:36 <cocreature> I’m not sure where --for-hackage comes into play
18:37 <cocreature> maybe it’s already processed in cabal-install?
18:37 <cocreature> hm doesn’t look like it
18:37 <ertes> --for-hackage Collection of flags to generate documentation suitable for upload to hackage
18:38 <ertes> i can imagine that cabal-install also generates the tar.gz
18:38 <ertes> but cabal by itself doesn't, because that would require support libraries/tools
18:39 <ertes> well, doesn't matter… it's just an extra command
18:39 <bennofs> ertes: --for-hackage is implemented by Cabal-the-library and is just passed through by cabal-install
18:40 xenog joined
18:40 <bennofs> ertes: cabal-install has 'cabal upload --doc' though
18:41 <cocreature> I’m looking forward to the day when "cabal upload --doc" becomes the default and I don’t have to deal with missing docs anymore
18:41 blender1 joined
18:42 winmillwill joined
18:43 wroathe joined
18:43 <ertes> Cabal library version 1.24.0.0
18:43 <ertes> do you use a newer version?
18:43 SlashLife joined
18:44 <bennofs> ertes: ah it may be that cabal haddock in general, --for-hackage or not, does additional stuff compared to just ./Setup haddock
18:45 richi235 joined
18:46 <winmillwill> anyone have a good method for debugging when Setup hits "Encountered missing dependencies"?
18:46 frankpf joined
18:47 <ertes> winmillwill: it tells you which dependencies are missing
18:47 <winmillwill> yeah, I need more info though, ie where was it looking?
18:48 <ertes> winmillwill: in the case of cabal-install it looks at your local package database, the one 'cabal update' downloads, plus the sources you have added explicitly
18:48 newhoggy joined
18:48 bab joined
18:49 <ertes> winmillwill: 'cabal list' gives you a complete list, and 'cabal info' gives you version information on individual packages
18:51 torgdor joined
18:52 hybrid joined
18:52 blym_ joined
18:53 newhoggy joined
18:53 acarrico joined
18:53 <winmillwill> hmmm -- looks like I can't get there anyway because I'm doing this with nix and the failed build doesn't keep the package conf dir
18:53 wroathe joined
18:55 <Aruro> winmillwill: u can enter nix shell, there cabal will be ready for your failing build
18:55 <Aruro> and u can investigate whats wrong
18:55 halogenandtoast joined
19:00 splanch joined
19:01 newhoggy joined
19:01 maarhart joined
19:01 splanch_ joined
19:02 laplacian joined
19:03 robertc joined
19:04 abhiroop joined
19:05 themagician joined
19:05 <ertes> winmillwill: in that case you can examine the package set you're using via nix-repl
19:06 <ertes> winmillwill: use this command: nix-repl "<nixpkgs>"
19:06 <ertes> then you can tab-complete your way through haskellPackages.*
19:06 newhoggy joined
19:07 <winmillwill> I have no nix-repl...
19:07 diphuser joined
19:07 <ertes> yeah, it doesn't come with nix: nix-env -i nix-repl
19:07 <winmillwill> ah
19:09 <ertes> to see the version of, say, generic-deriving, type this: haskellPackages.generic-deriving.name
19:10 <winmillwill> should I use nix-repl in a nix-shell or does it matter?
19:12 srbaker joined
19:12 zeroed joined
19:12 zeroed joined
19:13 steeze joined
19:13 blym_ joined
19:14 buttbutter joined
19:15 hc joined
19:15 newhoggy joined
19:15 <winmillwill> ...and if I cd to the failed build and run nix-shell I don't have cabal
19:16 fXl joined
19:17 iomonad joined
19:17 boombanana joined
19:17 theelous3 joined
19:18 raichoo joined
19:19 wroathe joined
19:20 soniku joined
19:20 Cale joined
19:23 blym_ joined
19:24 ludat joined
19:25 conal joined
19:26 splurging joined
19:26 newhoggy joined
19:27 oisdk joined
19:28 kefin joined
19:28 tomphp joined
19:29 blender1 joined
19:30 JoshS joined
19:30 Levex joined
19:31 newhoggy joined
19:31 osa1 joined
19:31 osa1 joined
19:32 <arctictern> quick question about the Applicative ((->) a) instance. The type seems to be unnecessarily constrained. It's "(<*>) :: (a -> a -> b) -> (a -> a) -> a -> b", but wouldn't a type of "(<*>) :: (r -> a -> b) -> (r -> a) -> r -> b" (similar to the function Functor) make more sense?
19:33 kamog joined
19:33 <lyxia> it's already that general
19:34 systemfault joined
19:34 shesek joined
19:34 <arctictern> do the a's not have to be the same type?
19:34 <lyxia> Not at all
19:35 splanch joined
19:35 <arctictern> hm i thought that was the case
19:35 _sg joined
19:36 Achylles joined
19:36 <lyxia> f (a -> b) -> f a -> f b, you want to substitute f with ((->) a) but first you can rename
19:36 <lyxia> so instead substitute with ((->) r)
19:36 srbaker joined
19:36 <arctictern> ok so it's different from, say, "head :: [a] -> a" means
19:36 <lyxia> there's a bit of confusion about where a is bound
19:36 newhoggy joined
19:36 insitu joined
19:36 <arctictern> and it's different because the a in ((->) a) and the other a get bound differently?
19:37 <lyxia> yes
19:38 <lyxia> Given an instance Applicative f, the type of (<*>) is more explicitly forall a b. m (a -> b) -> m a -> m b
19:38 <lyxia> a and b may not occur in m
19:39 <lyxia> oops, I mean Applicative m
19:41 <arctictern> Ok that makes sense, thanks. More generally, if a type appears in the "header" of an instance, e.g. the ((->) a) in Applicative ((->) a), then is it safe to say that it is independent of the types in the definition?
19:41 biglama joined
19:41 <arctictern> I worded that fairly poorly, but not sure what certain parts are called
19:41 <Cale> Yeah, that's normally called the "instance head"
19:41 saurik joined
19:42 <Cale> Usually the types are independent, but with scoped type variables, you can make them available
19:42 newhoggy joined
19:42 <Cale> Though, you also won't be giving a type signature to the operations you're defining in the instance usually.
19:43 <Cale> It's implied by the class declaration, and Haskell 98/2010 won't let you write one there
19:43 beerdrop joined
19:43 <Cale> You can turn on InstanceSigs if you really want to give type signatures in instance declarations.
19:44 <arctictern> gotcha, thanks!
19:44 Yuras joined
19:45 xenog joined
19:45 iomonad joined
19:46 Mutter joined
19:46 justanotheruser joined
19:47 augur joined
19:50 segmond joined
19:50 darjeeling_ joined
19:51 argent0 joined
19:52 newhoggy joined
19:52 JonReed joined
19:54 geekosaur joined
19:55 shafox joined
19:55 Noldorin joined
19:56 mszczygiel joined
19:56 richi235 joined
19:56 srbaker_ joined
19:56 ckubrak joined
19:57 sleffy joined
19:58 Levex joined
19:59 blym_ joined
20:01 Maxou joined
20:01 bollu joined
20:02 m0cesta joined
20:02 biglambda joined
20:03 newhoggy joined
20:04 Goplat joined
20:06 AndiK joined
20:06 jmnoz joined
20:08 bennofs1 joined
20:08 newhoggy joined
20:11 blym_ joined
20:11 nshepperd joined
20:13 <ertes> winmillwill: you need to use cabal in such an environment… personally i just compile the Setup script
20:13 newhoggy joined
20:15 shafox joined
20:19 wroathe joined
20:19 akr[m] left
20:19 doomlord joined
20:23 blym_ joined
20:23 CoderPuppy joined
20:25 <Gurkenglas> Is there a version of filtered that takes an (a -> Maybe b) and somehow gives access to the b while a is being traversed?
20:25 newhoggy joined
20:26 <Gurkenglas> *read access
20:27 <jle`> Gurkenglas: what is the type of what you're looking for?
20:28 <Gurkenglas> Applicative f => (a -> Maybe b) -> (b -> a -> f a) -> a -> f a
20:29 oisdk_ joined
20:30 Paulish joined
20:31 <Gurkenglas> :t \f small -> liftA3 maybe pure small f
20:31 <lambdabot> Applicative f => (a1 -> Maybe a) -> (a1 -> a -> f a1) -> a1 -> f a1
20:31 <Paulish> haskell is cool for web development?
20:32 cpup joined
20:32 fotonzade joined
20:33 tv joined
20:33 tv joined
20:35 shafox joined
20:36 fresheyeball joined
20:36 <fresheyeball> how do yall feel about unit tests?
20:36 <fresheyeball> The longer I write pure fp code, the less I see a need for them
20:37 <fresheyeball> but there are also lots of testing tools for Haskell
20:37 <fresheyeball> so obviously others feel differently from me
20:38 newhoggy joined
20:38 darjeeling_ joined
20:39 abhiroop joined
20:39 laplacian joined
20:40 <lyxia> parametricity helps avoid some testing
20:41 <lyxia> but a lot can go wrong in a large enough project
20:41 BartAdv joined
20:41 <monochrom> Right, you will still like to include a few unit tests and a few Quickcheck tests.
20:42 <monochrom> But not as many as Python projects.
20:42 <ggVGc> fresheyeball: my philosophy is often to unit test whe bug fixing but not initially
20:42 <ggVGc> but in reality I seldom follow it
20:42 <ggVGc> unfortunately
20:42 <ggVGc> simply because, well, Im lazy
20:42 <ggVGc> and I want to make more features
20:42 <monochrom> And Quickcheck is a triumphant story. Quickcheck was cool before fuzz-testing is cool. (Same difference.)
20:43 abhiroop joined
20:44 epsilonhalbe joined
20:45 codesoup joined
20:46 newhoggy joined
20:46 <sproingie> unit tests are good for integrating stuff. you can still build a complete wreck out of precision-made parts
20:47 blym_ joined
20:47 <sproingie> it's nice to find where your assumptions went wrong before you put everything together. you're not debugging your code as much as you're debugging you
20:47 steeze joined
20:47 aarvar joined
20:48 bjz joined
20:50 epsilonhalbe left
20:50 oisdk joined
20:52 marr joined
20:55 newhoggy joined
20:55 shafox joined
20:56 doomlord joined
20:56 blym_ joined
20:56 abhiroop joined
20:57 fXl joined
20:58 ertesx joined
20:59 mjora7 joined
21:01 e14 joined
21:01 dan_f joined
21:01 tomboy64 joined
21:01 justan0theruser joined
21:03 newhoggy joined
21:04 NeverDie joined
21:04 Paulish joined
21:04 anuxivm joined
21:07 NeverDie_ joined
21:08 newhoggy joined
21:09 Meanirelli joined
21:11 tommd joined
21:12 tlaxkit joined
21:12 abhiroop joined
21:16 shafox joined
21:17 int-index joined
21:18 newhoggy joined
21:19 <int-index> what package defines most canonical sum-types (in the same sense that tuples are canonical product-types)?
21:19 SadoqueTD joined
21:19 <int-index> basically, I need Either for 3, 4, 5, ..., 62 elements
21:20 <int-index> for now I'm thinking maybe 'compound-types'
21:20 <jle`> i don't think there is a common package providing distinct types for all those sums
21:20 <jle`> but what would you want to use them for?
21:20 <jle`> there are generic sum types that can be a sum between an arbitrary number of elements
21:23 <mniip> int-index, tried unboxed sums?
21:23 tommd joined
21:24 <int-index> Well, they're unboxed, and that's the problem.
21:24 dmwit joined
21:25 <int-index> jle`: I need memory-efficient sums, so that they are stored as tag + payload in memory, they also can't have a Typeable constraint.
21:26 <int-index> I could use something like (Word, Any) and a lot of unsafeCoerce. Btw, maybe there's a package like that...
21:26 <int-index> but for the sake of pattern-matching I'd prefer manually defined sum-types
21:27 <jle`> compound-types is probably the most direct realization of what you are asking for
21:27 <jle`> but, what do you really want?
21:27 e14 joined
21:27 <jle`> want to do?
21:28 <int-index> I want ExceptT (Sum5 E1 E2 E3 E4 E5)
21:28 <mniip> (# Word#, Addr# #)
21:28 <int-index> and similarly for any N
21:28 <int-index> mniip, unboxed sum types have non-* kind, correct?
21:28 <mniip> I'm not sure
21:28 <mniip> probably
21:28 <mniip> they have a different calling convention
21:29 <int-index> unless it's *, I can't use them as ExceptT parameter
21:29 <int-index> other than that they fit the bill
21:29 conal joined
21:29 Bane^ joined
21:29 <lyxia> (Word, Any) + unsafeCoerce sounds like a lot of fun
21:30 <int-index> (# Word#, Addr# #) won't have good pattern matching. I could define pattern-synonyms but they have bad interactions with exhaustiveness checker
21:30 akr[m] joined
21:30 <akr[m]> hello
21:30 <akr[m]> hello
21:31 <int-index> hello akr[m]
21:31 tomboy64 joined
21:31 <akr[m]> my `stack build` is failing with: Cabal-simple_mPHDZzAJ_1.18.1.5_ghc-7.8.4: The program cpphs is required but it could not be found.
21:31 <int-index> stack install cpp2hs
21:32 qzorg joined
21:33 <akr[m]> int-index (IRC): ah, thank you
21:33 <akr[m]> can I fix this in stack.yaml somehow?
21:33 <akr[m]> I mean, I do have cpphs in extra-deps…
21:34 <int-index> I don't think so, it's a tool dependency, you just need it in PATH
21:34 <int-index> stack manages libraries
21:36 shafox joined
21:38 <hvr> fwiw, cabal new-build also manages build-tools available on Hackage
21:39 <hvr> thereby allowing to have multiple versions of the same build-tool being used inside one install-plan
21:41 butterthebuddha joined
21:41 <int-index> cool, I should try new-build
21:41 <akr[m]> hmm okay
21:41 <akr[m]> what about necessary C system libraries? Do I have to install those manually as well?
21:41 jmnoz joined
21:42 <mniip> int-index, Addr# wasn't serious
21:42 <mniip> with Addr# you are playing a game with the GC
21:42 <int-index> whatever, 'Any' is safe there
21:43 <int-index> I haven't looked at what Addr# is
21:43 <int-index> (just copied your suggestion)
21:44 syrius_ left
21:44 <mniip> one thing worth mentioning, Any is not a type
21:44 <hvr> int-index: see also http://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-build-tool-depends
21:44 <mniip> I've run into this issue before
21:45 <int-index> it's a poly-kinded type family with no clauses, yep
21:45 <int-index> what issues can this cause? You can't define instances for it, but that's about it I would think
21:45 <jle`> int-index: pattern matching becomes kind of confusing for anonymous sums like that, especially if you want to modify or remove anything
21:45 <jle`> why not just define a custom error type?
21:45 <jle`> and do you handle errors often enough taht performance is a bottleneck?
21:45 <mniip> one sec
21:46 _flow_ joined
21:46 <abhiroop> Can someone please explain, in the notation Γ⊢TY σ:κ where TY is subscript, what does the TY mean? I mean I know Γ ⊢ σ:κ means in an environment Γ, σ is of type κ
21:47 bennofs joined
21:47 shafox joined
21:47 roconnor joined
21:47 <int-index> jle`, I'm looking for ways to flatten nested ExceptT. Right now I can use ExceptT E1 (ExceptT E2 (ExceptT E3 ...)) and it works great except for performance, so I'd like to flatten them
21:47 <int-index> I can't define a custom error type because I'm writing a library, not an application
21:48 <mniip> int-index, with some combination of extensions I've got 'put [undefined :: Any]' to be a type error
21:48 <jle`> would the user ever directly work with Sum5 E1 E2 E3 E4 E5 ?
21:48 <mniip> https://ghc.haskell.org/trac/ghc/ticket/10939
21:48 twanvl joined
21:48 <mniip> ah
21:48 <mniip> fixed since 7.10
21:49 <int-index> jle`, yes, when he writes `runExceptT` he well get `m (Either (Sum5 E1 E2 E3 E4 E5) a)`
21:49 <int-index> which is why I want good pattern matching
21:49 featherlessbiped joined
21:49 <jle`> if you're giving something to the user, you might as well use a custom Sum5 type
21:49 <jle`> that's more meaningful
21:49 <jle`> a throaway
21:49 <jle`> with meaningful constructors
21:50 <int-index> it's an effect libraries, those constructors don't have meaning, they are just a union of exceptions
21:50 <int-index> it's all for performance only
21:51 <jle`> are you working with a fixed E1/E2/E3 etc. set, that will never change?
21:51 blym joined
21:52 <int-index> No. I have a lib that defines custom `MonadReader`, `MonadState`, `MonadExcept` that unlike the ones for mtl allow for multiple effects in the same transformer stack
21:52 <int-index> e.g. with mtl you can't have `MonadReader r1 m, MonadReader r2 m`, but with my lib you can
21:52 <int-index> to handle those effects you could either use nested transformers (multiple ReaderT, StateT, ExceptT) or flatten them
21:52 hiratara joined
21:52 <int-index> to flatten ReaderT and StateT I use tuples, to flatten ExceptT I need sums
21:53 <mniip> what if you flatten 63 readers
21:53 <int-index> You'll have to flatten them to a custom type. I don't hardcode tuples, they're just the default options
21:53 MrWoohoo joined
21:54 <Gurkenglas> int-index, the last project I saw using multi-target reader/state/except eventually switched to using the regular version with lenses
21:54 <Gurkenglas> (um i think it was writer not except)
21:55 <int-index> the problem with the lensy approach is that you can't add layers on top. E.g. you can't flatten some layers but not all
21:55 <int-index> and sometimes you don't want to flatten some of the layers because they don't commute, e.g. ExceptT E1 (StateT S1 (ExceptT E2 ...)) can't be flattened.
21:56 <int-index> and sometimes you don't want to flatten because adding one more ReaderT on top is an implementation detail in some function
21:56 <int-index> and sometimes you don't want to flatten because you have both strict and lazy state
21:57 <Gurkenglas> But in those cases you never want to flatten, right? Is there a case where you don't know in advance which you'll want to flatten?
21:58 serendependy joined
21:58 <int-index> Well, let's say I have some 'm' that holds some environment and I want to use `ReaderT R m'. How do I access the inner environment? (anything involving lift doesn't count)
21:59 <Gurkenglas> I don't follow. You've only given me lift to work with.
21:59 <int-index> (the reason it doesn't count because there are operations, such as 'local', 'listen', 'pass', 'catch', that aren't trivial to lift manually)
22:00 <int-index> Gurkenglas, that's the point, with mtl you can't write 'f :: MonadReader a m => ReaderT b m a' and use 'local' for 'a'
22:00 <int-index> You'll have to resort to 'mapReaderT', and it's not nice
22:02 newhoggy joined
22:03 <int-index> Generally, I want to write code that doesn't know in advance whether it will be run flattened or not, and make the decision at call-site
22:03 Greezler joined
22:04 <lyxia> abhiroop: it's used to disambiguate different judgements
22:04 netheranthem joined
22:05 kadoban joined
22:06 <lyxia> abhiroop: it's useful to annotate the turnstile when you have multiple similar looking judgements with different rules.
22:06 <Gurkenglas> int-index, sounds like you want the dual of an anonymous record library
22:07 shafox joined
22:07 <int-index> Well, given that the anonymous record library is just a bunch of tuples with labels, you could put it like that
22:08 wroathe joined
22:08 Koterpillar joined
22:08 <abhiroop> lyxia: Thanks
22:11 Greezler joined
22:12 bjz joined
22:16 thebardian joined
22:17 Karma-Five-Ohm joined
22:17 shafox joined
22:17 thebardian left
22:21 zero_byte joined
22:26 fizbin joined
22:28 zachary joined
22:30 systemfault joined
22:31 hiratara joined
22:32 dustmote joined
22:34 augur joined
22:34 wroathe joined
22:37 shafox joined
22:38 oisdk joined
22:38 butterthebuddha joined
22:41 oisdk joined
22:44 cemd_ joined
22:44 laplacian joined
22:48 shafox joined
22:49 MP2E joined
22:52 newhoggy joined
22:53 randomclown joined
22:53 Proteus joined
22:54 conal joined
22:54 fXl joined
22:55 Greezler joined
22:57 taktoa joined
22:58 Csmnt joined
22:58 hexfive joined
23:00 <Csmnt> Anyone here built llvm for accelerate? I'm trying to build it from source, set it to shared, but I'm missing libLLVMLanaiInstPrinter, which is needed by accelerate-llvm. I've ran into wall with google and hoping someone has more information here
23:01 ChaiTRex joined
23:03 mada joined
23:04 Welkin joined
23:04 theDon_ joined
23:04 danthemyth joined
23:05 NeverDie joined
23:08 oisdk_ joined
23:08 shafox joined
23:11 abhiroop joined
23:13 dmwit_ joined
23:18 Gentilhomme joined
23:19 fragamus joined
23:20 Achylles joined
23:21 castlelore joined
23:22 boek joined
23:24 e14 joined
23:27 lambda-11235 joined
23:28 shafox joined
23:29 jrajav joined
23:32 mjora7 joined
23:33 blender1 joined
23:38 Itkovian joined
23:39 yellowj joined
23:40 zachary joined
23:42 binaryplease joined
23:42 sigmundv__ joined
23:44 oisdk joined
23:44 taksuyu joined
23:44 eacameron joined
23:47 binaryplease joined
23:48 taksuyu joined
23:48 shafox joined
23:50 AfC joined
23:51 mjora7 joined
23:51 <AfC> If I add a custom-setup stanza to the library's .cabal file (as I have been recommended to do), should I up the cabal-version: field? Presumably _not_, for backward compatibility.
23:51 conal joined
23:52 {emptyset} joined
23:55 eacameron joined
23:56 robogoat joined
23:56 markus1209 joined
23:56 YongJoon joined
23:57 markus1219 joined
23:57 vaibhavsagar joined
23:58 infinity0 joined
23:58 YongJoon joined