<    March 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 _2_4 25  
26 27 28 29 30 31
00:11 suls joined
00:17 DataComputist joined
00:19 eacameron joined
00:27 <geppettodivacin> @tell shoglok I added a potentially better exit condition to your code. http://lpaste.net/7609497281783398400
00:27 <lambdabot> Consider it noted.
00:27 <geppettodivacin> @tell shoglok Feel free to ask about it when you return.
00:27 <lambdabot> Consider it noted.
00:32 nomotif joined
00:35 meandi_2 joined
00:38 takle joined
00:41 <parsnip> having some trouble matching items in "[hello:\"world\" add:\"1\"]\n[hello:\"end space\" add:\"2\"]\n"
00:41 <parsnip> using Parsec
00:42 <parsnip> i think i need to make sure i'm matching items like "\"end space\"" correctly
00:42 <parsnip> i'm thinking to use a `between (string "\"") (string "\"") anyChar`
00:43 <monochrom> But anyChar will eat your closing quotes.
00:43 <parsnip> er, (many anyChar)
00:43 <monochrom> you will need noneOf.
00:44 <parsnip> maybe a lookAhead?
00:45 <monochrom> No, lookAhead and notFollowedBy will complicate the matter.
00:45 <parsnip> that fixes that parse, yes
00:46 <parsnip> but i may encounter other escaped items in the string, like \' i think
00:47 <monochrom> noneOf "\"'"
00:47 <monochrom> or equivalently, noneOf [ '"', '\'' ]
00:48 <parsnip> monochrom: wouldn't that skip \', i need to eat it so users can have \' in the value
00:49 <parsnip> https://taskwarrior.org/docs/escapes.html
00:50 <monochrom> I don't understand the question, but you now know of noneOf and you can control how many levels of ecaping you need.
00:50 <parsnip> hmm, yeah, i guess i can wait till i see it actually break
00:50 <parsnip> thanks
00:53 Decoy joined
01:02 mac10688 joined
01:17 dpren joined
01:22 malaclyps joined
01:38 <parsnip> monochrom: ooohhhh, i did not realize \" was a single char, i can simply do the noneOf, sorry for not seeing that! >.<
01:45 uglyfigurine joined
01:46 eacameron joined
01:53 drewr joined
02:10 uglyfigurine joined
02:12 DataComputist joined
02:12 modori518 joined
02:15 eacameron joined
02:18 gpolitis joined
02:18 Sornaensis joined
02:19 threshold joined
02:21 conal joined
02:23 Gurkenglas joined
02:24 Jackoe joined
02:24 Jackoe joined
02:33 gpolitis joined
02:43 <mounty> I'm thinking about setting up CI for a Haskell project; do people generally use Jenkins/Hudson or is there a more Haskellish solution?
03:06 mac10688 joined
03:08 eacameron joined
03:21 trudyjane joined
03:23 nocturne777 joined
03:28 <mounty> There is Bake but it appears to be abandoned, regrettably.
03:38 exferenceBot joined
03:41 jrm joined
03:43 hexagoxel joined
03:47 trudyjane joined
03:47 hphuoc25 joined
03:53 gpolitis joined
03:54 hphuoc25 joined
03:58 conal joined
04:11 eacameron joined
04:11 DataComputist joined
04:21 aarvar joined
04:34 RageD joined
04:39 takle joined
04:47 hexagoxel joined
04:54 surtn joined
05:02 nepiktaz joined
05:07 dedgrant joined
05:13 hexagoxel joined
05:19 hphuoc25_ joined
05:21 splanch_ joined
05:23 slomo joined
05:23 slomo joined
05:24 hphuoc25 joined
05:35 hphuoc25 joined
05:43 hphuoc25_ joined
05:52 eacameron joined
05:56 takle joined
06:04 meandi_3 joined
06:04 DataComputist joined
06:05 DataComputist joined
06:05 splanch joined
06:09 DataComputist joined
06:11 eacameron joined
06:11 gmg85 joined
06:14 Pupnik joined
06:15 DataComputist joined
06:17 DataComputist joined
06:17 DataComputist joined
06:18 DataComputist joined
06:23 hphuoc25 joined
06:24 splanch joined
06:32 eacameron joined
06:34 hexagoxel joined
06:40 DataComputist joined
06:43 louispan joined
06:44 ThomasLocke joined
06:44 shayan_ joined
06:46 ThomasLocke_ joined
06:46 ThomasLocke_ joined
06:48 DataComputist joined
06:49 DataComputist joined
06:55 hvr joined
06:59 owiecc joined
07:01 eacameron joined
07:03 kritzcreek_ joined
07:06 galderz joined
07:11 hoffmeyer joined
07:22 DataComputist joined
07:23 Deide joined
07:24 DataComputist joined
07:31 eacameron joined
07:33 DataComputist joined
07:35 eacameron joined
07:41 nepiktaz joined
07:45 DataComputist joined
07:46 eacameron joined
07:47 hexagoxel joined
07:48 hphuoc25 joined
07:56 hphuoc25 joined
07:57 takle joined
07:58 hphuoc25 joined
08:06 owiecc joined
08:10 DataComputist joined
08:12 suls joined
08:13 mattyw joined
08:13 hphuoc25 joined
08:13 DataComputist joined
08:18 DataComputist joined
08:22 DataComputist joined
08:23 suls joined
08:30 colt44 joined
08:31 DataComputist joined
08:33 skapazzo joined
08:36 hphuoc25 joined
08:38 Prutheus joined
08:39 hphuoc25 joined
08:45 ThomasLocke joined
08:46 DataComputist joined
08:47 louispan joined
08:48 thc202 joined
08:49 gregman_ joined
08:49 DataComputist joined
08:52 DataComputist joined
08:59 DataComputist joined
08:59 <dmj`> mounty: hydra and nixos are nice, if you dont’ want to use nix, circle ci and stack are nice
09:00 DataComputist joined
09:02 tjb0607 joined
09:06 takle joined
09:09 mengu joined
09:19 merijn joined
09:19 DataComputist joined
09:22 DataComputist joined
09:22 DataComputist joined
09:25 hexagoxel joined
09:27 nomotif joined
09:33 DataComputist joined
09:40 hphuoc25 joined
09:41 DataComputist joined
09:44 Durz0 joined
09:44 Miroboru joined
09:47 hphuoc25 joined
09:54 t0by joined
10:03 DataComputist joined
10:10 <mounty> Thanks dmj`; I'll have a look.
10:10 <dmj`> if this is an open source project, travis and the ghc build matrix might work well
10:11 cydo joined
10:12 <cydo> Hi! I'm leaning haskell with the haskell book and have a question
10:12 <mounty> I'd have to check the licence there because although it's open-source now, I intend to capitalise on it and offer consultancy services.
10:12 <cydo> How is it possible that "4 :: Product Int" is actually recognized as a product?
10:13 DataComputist joined
10:13 <dmj`> cydo: Product might have a Num constraint
10:13 <dmj`> Num a => Product a
10:14 <cydo> So, fromInteger is automatically applied in this case?
10:14 <dmj`> Num a => Num (Product a)
10:14 <dmj`> yes
10:14 <dmj`> do this
10:14 <dmj`> newtype MyInt = MyInt Int deriving (Num)
10:15 <dmj`> 4 :: MyInt
10:15 <dmj`> will typecheck
10:15 <cydo> oh ok, I did not know you could derive Num
10:15 <cydo> awesome, thank you :)
10:15 <dmj`> caveat emptor
10:15 <cydo> but how does the compiler know to use fromInteger here? is is built-in the language?
10:15 <cydo> or is there a feature allowing conversion
10:16 <dmj`> cydo: what is the type of fromInteger ?
10:16 <cydo> Integer -> a
10:16 <dmj`> is it :)
10:16 <dmj`> fromInteger :: Num a => Integer -> a
10:17 <cydo> right
10:17 <dmj`> you’ll need an extension too
10:17 <dmj`> {-# LANGUAGE GeneralizedNewtypeDeriving #-}
10:18 <merijn> cydo: fromInteger is part of the Num typeclass
10:19 <mounty> Travis and Circle CI are both hosted services. I've set up a Jenkins server at work so am happy to do so again and obtain the benefits of complete control.
10:19 <mounty> In any case, the hassle of setting-up the CI is as nothing compared with the hassle of actually writing the tests.
10:19 <cydo> but what if there were two functions in the typeclass with the same signature?
10:19 <merijn> cydo: And the language reports explicitly defines numeric literals to be polymorphic
10:19 <merijn> :t 4
10:19 <lambdabot> Num t => t
10:19 <dmj`> cydo: it’s inheriting the Num instance from Int
10:19 <cydo> oh okay :)
10:19 <cydo> aaah right, that was the missing piece
10:19 <cydo> thank you, i get it
10:19 <merijn> cydo: The report specifies the numeric literal 4 is equivalent to 'fromInteger 4' :)
10:20 <merijn> The nice thing is that this means literals automagically work if you define a new Num instance :)
10:20 <merijn> If, instead of using the extension dmj` mentioned, you just wrote a Num instance by hand it'd "Just Work (TM)"
10:20 <cydo> this is really really cool
10:21 <cydo> haskell is really impressive
10:21 madjestic joined
10:21 <cydo> :D
10:21 <cydo> thank you
10:22 DataComputist joined
10:22 <merijn> There's a few warts with the system (such as dealing with overflow, negative numbers, etc.) but overall it's nice
10:23 <cydo> this makes usage of integer monoids a bit simpler though
10:23 <cydo> not sure if I will ever need them in real code, but still
10:24 <merijn> cydo: Not often, but they crop occasionally in useful things
10:24 <dmj`> cydo: you’ll soon be surprised what you find to be “necessary” in real code
10:24 <cydo> do you have any example in mind?
10:25 <cydo> well, I find it a bit hard to reason with abstractions in mind for now
10:25 <cydo> so not sure if I would be able to use them for awesome code :)
10:26 <merijn> cydo: Counting occurences of a certain type in a list using "Map k (Sum Integer)"
10:27 <merijn> Simply "map (, Sum 1)" over the list and then a fold that mappends elements
10:28 <merijn> I think I actually wrote a newtype for Map to use a different Monoid. The default is "Ord k => Monoid (Map k v)"
10:28 <merijn> But I wanted "(Ord k, Monoid v) => Monoid (Map k v)"
10:28 DataComputist joined
10:28 <merijn> Then you can simply mappend a list of singleton maps :)
10:29 <cydo> in this case, can you still keep the benefits from the standard library Data.Monoid?
10:29 <cydo> or do you have to "rewrite" all functions you need?
10:29 <merijn> cydo: All the stuff in Data.Monoid works for any Monoid, that's the nice thing
10:29 <merijn> Actually, lemme propose a newtype for this...
10:30 <cydo> so the map, now being a Monoid can automatically do a frequency map...
10:30 <cydo> that's quite incredible
10:30 <merijn> cydo: Map is already a monoid, but not that one I'd want. By default it's a left-biased union
10:31 <merijn> But by newtyping and giving a new Monoid instance for the newtype, yes, that works
10:31 <cydo> yay i get it
10:31 <cydo> i wonder if I will ever be able to get a job in Haskell
10:31 <cydo> not sure if there are so many :(
10:32 <cydo> but the language is so challenging and good
10:32 <cydo> I'm having a lot of fun learning it!
10:34 DataComputist joined
10:34 splanch joined
10:35 <Geekingfrog> What logging library would you recommend? I'm looking at https://github.com/wdanilo/haskell-logger , the last commit is over a year ago and I don't know if it's because it's done or abandonned :/
10:37 DataComputist joined
10:44 DataComputist joined
10:51 DataComputist joined
10:54 <Akii> I'm doing it wrong
10:54 <Akii> just thought "hey I need something to try a MonadError and if it fails just recover"
10:55 <Akii> and it's already defined catchError :: m a -> (e -> m a) -> m a
10:56 splanch joined
10:58 splanch_ joined
11:03 <jle`> Geekingfrog: i''ve been happy with monad-logger
11:06 <Geekingfrog> logging-effect looks quite nice as well.
11:08 eacameron joined
11:09 splanch joined
11:13 nepiktaz joined
11:15 hoffmeyer joined
11:22 DataComputist joined
11:23 DataComputist joined
11:23 DataComputist joined
11:23 DataComputist joined
11:24 DataComputist joined
11:25 DataComputist joined
11:33 Gloomy joined
11:33 netheranthem joined
11:35 colt44 joined
11:37 snowcrshd joined
11:45 jomg joined
11:50 <Geekingfrog> I'm looking at the source of partitionEithers (http://hackage.haskell.org/package/base- and I'm confused by the pattern ~(l, r). What is that ?
11:51 <merijn> Lazy pattern match
11:51 <merijn> i.e., one that isn't evaluated until l or r are used
11:51 <merijn> > case undefined of (l, r) -> "Whoo!"
11:51 <lambdabot> "*Exception: Prelude.undefined
11:51 <merijn> > case undefined of ~(l, r) -> "Whoo!"
11:51 <lambdabot> "Whoo!"
11:52 <merijn> > case undefined of ~(l, r) -> "Whoo!" ++ l
11:52 <lambdabot> "Whoo!*Exception: Prelude.undefined
11:52 <merijn> > case undefined of (l, r) -> "Whoo!" ++ l -- final one
11:52 <lambdabot> "*Exception: Prelude.undefined
11:52 <Geekingfrog> Why is the lazy pattern matching required for partitionEithers ?
11:55 <merijn> Honestly, I'm not sure
11:58 Rizy joined
12:03 ederign joined
12:05 eacameron joined
12:05 pbrant joined
12:17 hphuoc25 joined
12:17 <hexagoxel> > bimap (take 1) (take 1) $ partitionEithers [Left 1, Right 1, undefined]
12:17 <lambdabot> ([1],[1])
12:17 <hexagoxel> > bimap (take 1) (take 1) $ partitionEithers' [Left 1, Right 1, undefined]
12:17 <lambdabot> (*Exception: Prelude.undefined
12:19 <hexagoxel> Geekingfrog: the latter is without lazy pattermatch. it is strict in the input by forcing (,).
12:20 pbrant joined
12:20 <Geekingfrog> Cool. Not sure exactly what's going on but I'll dig in.
12:27 <hexagoxel> Geekingfrog: `either left right` takes in an `Either a b` and a tuple. if the tuple is forced, you force "the next iteration" because the tuple constructor is in `left`/`right`, and forcing that means we look at the next input element. and so on.
12:27 <hexagoxel> the way the tuple is constructed/destructed means that without lazy pattermatch, you get the effects of a foldr'.
12:30 splanch joined
12:33 Axman6 joined
12:50 hphuoc25 joined
12:53 hphuoc25 joined
12:59 harfangk joined
13:01 drewr joined
13:15 wei2912 joined
13:15 Gloomy joined
13:21 mizu_no_oto_work joined
13:23 <drewr> mounty: not really haskelly per se, but https://concourse.ci/ is nice
13:30 splanch joined
13:35 mengu joined
13:40 emmanuel_erc joined
13:42 takle joined
13:54 carlomagno joined
13:59 eacameron joined
14:03 zaquest joined
14:06 miguelv joined
14:07 mengu joined
14:16 Uniaika joined
14:18 splanch joined
14:25 chlong joined
14:29 drewr joined
14:39 eacameron joined
14:40 splanch joined
14:58 splanch joined
15:01 uglyfigurine joined
15:03 uglyfigurine joined
15:04 <Akii> what type do I use to get reliable floats in Haskell?
15:08 <benzrf> Akii: what do yu mean by reliable?
15:09 <merijn> Akii: Did you mean "I want perfect precision"?
15:09 <Akii> having reliable addition fx.
15:09 <merijn> What do you mean by reliable?
15:09 <Akii> no rounding mistakes and the like
15:09 <merijn> Float is perfectly reliable, but only if your model is IEEE754 floating point, not if your model is "rationals"
15:10 <merijn> Akii: Will rationals do? Or do you need reals?
15:10 <Akii> I'll have to look into what rationals are ^^
15:10 <Akii> thanks for the pointer
15:10 <Akii> benzrf: did you get my link to my domain problem yesterday?
15:10 <merijn> Akii: Rationals are all numbers that can be represented by 1) a fraction or 2) a finite number of decimals
15:10 <benzrf> Akii: ah, no sorry
15:10 <merijn> Well, I suppose those are the same thing :p
15:10 <Akii> because I'm going crazy
15:11 <benzrf> Akii: you don't want floats
15:11 <merijn> Akii: For example, pi is a real, not a rational since it's infinite length
15:11 <merijn> (and not a fraction)
15:11 <Akii> benzrf: http://lpaste.net/353855
15:11 <benzrf> floats are explicitly fixed-precision, so by definition you won't have reliable math
15:11 <benzrf> you want some kind of fractional type, but that's more general than "float"
15:11 <benzrf> merijn: a fraction of integers
15:11 <benzrf> pi is certainly equal to 3pi/3
15:11 <merijn> Akii: Can you describe what you're trying to represent? :)
15:12 <Akii> merijn: User provides a number that contains a comma; I need to sum that
15:12 shayan_ joined
15:12 <Akii> and idk how many problems we had with this
15:12 <merijn> ok, then Rational will work :)
15:12 <Akii> kay, will try those out. thanks!
15:12 <merijn> Since your user, presumably, is not allowed to enter infinite length numbers :p
15:12 <merijn> > 1 % 3
15:12 <lambdabot> 1 % 3
15:12 <merijn> > 1 % 3 + 2 % 3
15:13 <lambdabot> 1 % 1
15:14 <Akii> hehe "{\"numerator\":13,\"denominator\":10}"
15:14 drewr joined
15:14 <Akii> just converted that to JSON
15:14 <Akii> to see what happens
15:18 jmiven joined
15:19 <Akii> benzrf: if anything is unclear or if it's just too much just let me know ^^
15:30 <* Akii> scares away anyone with bad domain logic
15:32 uglyfigurine joined
15:34 Rodya_ joined
15:36 creeefs joined
15:37 Gurkenglas joined
15:43 Gurkenglas_ joined
15:49 <nitrix> :t kemonomimify "Akii" Kitty
15:49 <lambdabot> Animal
15:49 <nitrix> Not bad, now I need to figure the same thing with dependent types and obtain an `Animal Cat` :D
15:49 <Akii> wat
15:51 <Akii> I need a lenses crashcourse
15:51 <Akii> might be something for the weekend
15:53 hoffmeyer joined
15:54 <Akii> dafuq is kemonomimify
15:59 mengu joined
16:02 <nitrix> :t kemonomimify
16:02 <lambdabot> Human -> Ears -> Animal
16:03 <nitrix> It turns a Human into an Animal by adding the ears of your choice.
16:03 <* nitrix> giggles
16:05 <nitrix> Had I been more cleaver, I would've made it produce a URL instead of bottom.
16:07 conal_ joined
16:12 openheavens joined
16:13 <openheavens> Could anyone please explain to me how to identify an expression in Weak Head Normal Form?
16:14 owiecc joined
16:16 Vzox01 joined
16:18 mojjo joined
16:19 zero_byte joined
16:20 <nitrix> openheavens: It's in weak-head normal form if it cannot be reduced further.
16:20 <nitrix> openheavens: Is `42` NF or WHNF ?
16:20 <openheavens> I understand that 42 is both NF and WHNF
16:21 <openheavens> because 42 cannot be reduced further
16:21 <nitrix> As far as I know, 42 is normal form.
16:21 <nitrix> openheavens: Yes and this extends to data constructors as well as lambdas.
16:22 <nitrix> Just 42 is normal form, (0, 0) is normal form, so is \x -> x + 1
16:22 <openheavens> ok..
16:23 <nitrix> openheavens: Notice how `Just 42` cannot be reduced further, neither can `(0, 0)` be reduced further and same with the lambda as we have nothing to apply it on.
16:23 <nitrix> openheavens: `(\x -> x + 1) 42` would be WHNF.
16:24 <nitrix> As you obtain a thunk representing the computation that is applying the lambda to 42, the computation can be further reduced by doing the application.
16:24 <openheavens> ok
16:25 peterbecich joined
16:25 <nitrix> Same with 1 + 1, it's WHNF and 'h' : "askell", both are weak head normal forms as they can be reduced further.
16:25 <nitrix> openheavens: Does this helps?
16:26 <openheavens> yes, it does.. Thank you very much
16:28 <nitrix> openheavens: Normally I don't bring up thunks because it's an operational concept of GHC inner workings, but lazy evaluation essentially relies on it.
16:28 hs428 joined
16:28 <openheavens> ok..
16:28 <nitrix> openheavens: https://i.stack.imgur.com/1leiT.png
16:29 <openheavens> understood. The image makes things clearer.
16:31 <nitrix> openheavens: I prefer the earlier examples but I know that image works for some and their mental blockers :P
16:31 splanch joined
16:32 vmeson joined
16:34 expo873 joined
16:42 <glguy> `(\x -> x + 1) 42` is *not* WHNF
16:42 <glguy> but maybe I'm misreading the backlog
16:43 <glguy> Also: 1 + 1 isn't WHNF
16:43 sigmundv_ joined
16:45 <glguy> Weak head normal form doesn't mean "can be reduced further"
16:47 <nitrix> glguy: If we ignore HNF, I'd like to know where I'm mistaken.
16:48 <nitrix> As far as Haskell is concerned, `1+1` and `(\x -> x + 1) 42` should clearly not be NF, which only leaves WHNF. HNF is irrelevant for Haskell, unless very specific cases like `seq`.
16:48 <glguy> nitrix: Start here https://wiki.haskell.org/Weak_he…
16:48 <glguy> https://wiki.haskell.org/Weak_head_normal_form
16:48 <glguy> There are the 3 bullets of things that are WHNF
16:48 <nitrix> glguy: I've read the material so reading it once more will probably lead me to the same conclusion.
16:48 <nitrix> glguy: Mind explaining where I went wrong?
16:49 <glguy> A lambda applied to an argument is not going to be WHNF since the outermost constructor isn't known
16:50 <glguy> so Just (1+1) is WHNF
16:50 <glguy> the outermost constructor is known, but it's in in NF as there are stuff left to reduce, the 1+1
16:51 <Geekingfrog> you mean *not* in NF I guess ?
16:51 <glguy> everything that is NF is WHNF
16:51 <srhb> s/in in/not in/
16:51 <srhb> yes
16:51 <glguy> yeah, in in -> not in
16:52 <nitrix> glguy: Just (1+1) is WHNF, I agree. Do you have other examples?
16:52 <glguy> Of things that *are* WHNF?
16:52 <srhb> nitrix: I'm not sure, but something you said lead me to think you are trying to shoehorn all things into being either in NF or WHNF while they can be neither.
16:53 <nitrix> srhb: What's an example of "neither" that still applies to Haskell?
16:53 <glguy> 1+1 is neither WHNF nor NF
16:53 <nitrix> glguy: Whichever, see if you definition matches with mine until we find where my misunderstanding is.
16:53 <glguy> ok, so we agree that 1+1 is neither?
16:54 <glguy> and (\x -> x + 1) 42 is neither WHNF nor NF
16:54 <nitrix> glguy: How about (+1) 1 1
16:54 <nitrix> sorry
16:54 <nitrix> glguy: How about (+) 1 1
16:54 <glguy> that's exactly the same as 1+1, neither
16:54 <Geekingfrog> isn't that the same as 1 + 1 ?
16:54 <glguy> (+) is not a constructor
16:54 <glguy> or a built-in function applied to too few arguments
16:55 <glguy> or a lone lambda
16:55 <nitrix> That is so freaking arbitrary.
16:55 <nitrix> Haskell is messed up.
16:55 <glguy> (+) computes, You can't match on it, it's different from constructors
16:55 <glguy> It's not arbitrary at all
16:56 <nitrix> You're supposed to be able to reduce (1 + 2 + 3) in which ever order, (1 + (2 + 3)) or ((1 + 2) + 3), and obtain the same normal form 6.
16:56 <glguy> constructors are distinct elements not equal to any other constructors
16:56 <nitrix> And these are supposed to be WHNF.
16:56 <glguy> The fact that + is associative isn't a general requirement of functions in Haskell
16:56 <nitrix> I don't know why Haskell is begging to differ or bend the terminology.
16:56 <glguy> and no terminology is being bent
16:57 <glguy> It's true that whether you reduce: ((1+2)+(3+4)) as (3+(3+4)) or ((1+2)+7) that you get the same answer
16:57 <hs428> nitrix: If you have integers WHNF and NF are exactly the same, only the result can be WHNF or NF
16:58 <hs428> that is with the usual integer definition anyway
16:58 <nitrix> I think that's a sign I need to invest time in other programming languages.
16:58 <glguy> and none of these are WHNF : (1 + 2 + 3) (1 + (2 + 3)) or ((1 + 2) + 3)
16:58 <nitrix> That's ridiculous.
16:58 <merijn> nitrix: What is?
16:59 nitrix left
16:59 <hs428> WHNF means that the "top" part of the expression is already evaluated
16:59 <hs428> oh well, he's gone
16:59 <Geekingfrog> ragequit over WHNF ?
17:00 <srhb> Frustration happens..
17:03 Zialus joined
17:13 peterbecich joined
17:13 peterbec` joined
17:19 jomg joined
17:19 ederign joined
17:26 Gurkenglas_ joined
17:26 owiecc joined
17:33 peterbecich joined
17:34 zero_byte joined
17:35 nokomo joined
17:38 aarvar joined