<     May 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 _2_5 26 27  
28 29 30 31
00:03 dni- joined
00:05 ploop joined
00:05 Dance_ joined
00:11 Dance_ joined
00:15 colt44 joined
00:17 aarvar joined
00:34 Youmu joined
00:36 aarvar joined
00:37 ridho joined
00:39 efm joined
00:44 cschneid_ joined
00:45 cschnei__ joined
00:48 c4r50nz joined
00:57 cschneid_ joined
00:59 lpaste joined
01:02 ploop joined
01:09 Guest88002 joined
01:13 sigmundv joined
01:16 Dance_ joined
01:18 hkailahi joined
01:22 takle joined
01:24 richard_ joined
01:26 richard_ joined
01:27 richard_ joined
01:33 gothos joined
01:41 lpaste joined
01:52 dni- joined
02:00 haskelleksah joined
02:02 hvr joined
02:02 hvr joined
02:04 takle joined
02:04 gothos joined
02:15 uglyfigurine joined
02:15 takle joined
02:16 blissdev joined
02:20 uglyfigu_ joined
02:23 aarvar joined
02:25 andyhoang joined
02:25 takle joined
02:33 exferenceBot joined
02:37 hexagoxel joined
02:39 uglyfigurine joined
02:44 louispan joined
02:45 takle joined
02:52 uglyfigurine joined
02:57 lpaste joined
03:04 zipper joined
03:08 takle joined
03:11 govg joined
03:29 andyhoang joined
03:35 moei joined
03:37 takle joined
03:41 dni- joined
03:42 louispan joined
03:43 malaclyps joined
03:48 <Guest44939> anyone know where I can go to get some help on automata?
03:50 <monochrom> stackoverflow
03:50 geekosaur joined
03:51 <thang1> I'm taking a class in that stuff right now if you wanna pester me about it
03:51 <thang1> (full disclosure: No claim to be able to answer more than basic questions)
03:53 <Guest44939> well I need to prove that a language is Context Free
03:53 <Guest44939> but how do I go about doing that?
03:54 <thang1> https://cs.stackexchange.com/questions/18524/how-to-prove-that-a-language-is-context-free/
03:54 <mniip> pumping lemma
03:54 <thang1> It's undecidable whetherh any given language is context free, so there's no set algorithm for this kinda thing
03:54 <thang1> mniip: that's for regularity, not context free
03:54 <monochrom> Two parts. The easy part is to give a context free grammar or pushdown automaton. The hard part is why what you give actually does exactly the language, no more no less.
03:55 <monochrom> No, pumping lemma can only disprove.
03:55 <mniip> ah I thought the idea is to disprove regularity
03:55 <mniip> well, uh, yeah, you'll need to build either a CFG or a PDA
03:56 <Guest44939> what's easier?
03:56 <thang1> I prefer CFG myself
03:56 <monochrom> Depends on the actual language.
03:56 <thang1> It depends on the language
03:57 <thang1> Some languages get really tricky to mess around with the stack, other languages are easier to visualize with a stack and are harder to see the patterns in the CFG
03:57 <Guest44939> if I gave the language could you tell me what is easier?
03:57 <monochrom> You will not find an easy just-do-this answer.
03:57 <Guest44939> I'm really not that great at this stuff
03:57 <monochrom> If this homework is due tomorrow, you are already too late.
03:57 <Guest44939> 2 days
03:57 <thang1> Probaly not, it really depends on your way of thinking about stuff
03:57 <thang1> I could tell you which way is easier for /me/
03:58 takle joined
03:58 <thang1> But, then again, I have my own way of breaking problems down
03:58 <monochrom> 2 days may be enough for a B-grade student.
03:59 <thang1> Just out of curiosity, are you a grad student Guest44939?
03:59 <Guest44939> no
03:59 <thang1> So then if it's gonna take 2 days to do a problem, you're likely overthinking it
04:00 <thang1> https://www.cs.rochester.edu/~nelson/courses/csc_173/grammars/cfg.html does this help at all?
04:01 <Guest44939> which part?
04:01 <monochrom> Overthinking is not necessarily caused by "the problem is easy, you assume it's hard".
04:02 <monochrom> It can also be caused by not having learned the basic properly therefore you overthink in the wrong direction.
04:02 <monochrom> which means the question is too hard (when compared to what little you've really learned so far)
04:04 <mniip> 1494388700 [06:58:20] <monochrom> 2 days may be enough for a B-grade student. <- huh?
04:05 <monochrom> Have you been a B-grade student?
04:06 <thang1> A B-grade student is someone who only tries to hit B and never really cares about perfection, I'm assuming?
04:06 <monochrom> No, not what I mean. A student who ends up with B, regardless of intention.
04:06 <thang1> ah got it
04:07 <thang1> I'm a b-grade student because of my adhd :p
04:08 louispan joined
04:09 <mniip> monochrom, then I'm not sure what that means
04:10 <monochrom> I was in a computer graphics class. There were programming assignments that took me 2 hours and worked the first time, but took my B or C classmates 2 weeks because they had trouble debugging theirs.
04:11 wei2912 joined
04:12 <thang1> Did you have programming experience prior to the class? Did they?
04:12 <monochrom> Lesson learned is that as an A-grade student I have no idea how and why other students need 10x as much time or something. But I can see the empirical outcome and remember it.
04:12 <monochrom> I had less programming experience than them. I was math major, they were compsci major.
04:13 <thang1> Interesting
04:13 <thang1> Some people's brains just click better with things like that.
04:13 <monochrom> But I did have 10x more linear algebra fluency than them. They could debug their matrices. My matrices were right the 1st time. Done.
04:13 <monochrom> err, they couldn't debug their matrices!
04:13 <thang1> That has a lot to do with it :p
04:14 <thang1> I've definitely had that sort of experience with people that should've been much more advanced than me. More often now that I'm at a larger university, I find that I'm outclassed by several peers. Luckily I still have a lot to offer, but it is an interesting feeling getting used to
04:15 <thang1> I was the genius in high school and now I'm realizing that, yeah I'm above average, but not really in CS. My spark comes from intuition and insight and being able to tell how to put things together, not so much from being able to program like a wizard
04:16 <monochrom> These CFG and PDA things are also pretty abstract and alien to most people. Whereas I can come up with a CFG (right on or close) in 5 minutes, other students can easily take 2 days and still draw a complete blank. I've seen it before.
04:16 <thang1> I did my CS homework in 20 minutes (it had a CFG and other stuff). I forgot to pay attention in class and had to google what a CFG was before I wrote it
04:17 <monochrom> :)
04:18 <MarcelineVQ> seems reasonable since I don't know what cfg and pda are
04:18 <thang1> No idea if I did it right: http://i.imgur.com/5K2UUMZ.png <-- looks mostly right though
04:18 govg joined
04:18 <thang1> (right half of screen is solution. Left half is homework assignment)
04:19 <thang1> MarcelineVQ: CFG = context free grammar. PDA = Pushdown Automata
04:20 <monochrom> Personal Digital Assistant! For example Palm and Newton.
04:21 <MarcelineVQ> ah alright pushdown automata, google reminded me of what cfg was but the same links assumed you knew what pda was :o
04:21 <thang1> don't worry I just learned what that was 20 minutes ago
04:21 <thang1> I had a midterm today and it had some PDAs in it and I didn't even know what the acronym stood for... lol
04:22 takle joined
04:22 <thang1> (probably only got a B because of it)
04:25 <monochrom> "S = S" is not, shall we say, very productive... :)
04:25 <thang1> ah damnit
04:25 <thang1> I forgot to change that to E lol
04:27 <monochrom> "babbb" should qualify, but how does your grammar produce it? Even after S=E.
04:27 <mniip> monochrom, ooh ooh I remember a cool assignment I've had on an exam
04:27 <mniip> I quickly came up with a 18-nonterm CFG and everyone was like 'wat'
04:28 <mniip> trying to remember what the language was...
04:28 <thang1> doh, forgot about that obvious one. It was pretty late and I was a little tired and out of it
04:29 <thang1> oh and aSaSa, etc should be E not S. Whoops
04:29 <mniip> something along the lines of
04:29 takle joined
04:30 <mniip> {x y | x \in a*b*a*, y \in b*a*b, |x|_a < |y|_b }
04:30 <mniip> something like that, iirc
04:30 <mniip> maybe
04:31 <thang1> that's a pretty weird language lol
04:31 <mniip> monochrom, I guess the skill of seeing this comes from applied programming
04:32 <mniip> first you program in C, then you program in assembly, then you program in FORTH, brainfuck, turing machines, automata, register machines, cfgs
04:32 <mniip> it's all about overcoming constraints
04:33 <mniip> finding basic building blocks in a completely alien area
04:36 <mniip> this is the same skill people use to build computers in minecraft
04:36 <mniip> I don't think I've ever heard a name for it
04:37 <thang1> abstraction? Tenacency? Stubbornness? :p
04:38 <mniip> is Tenacency a word?
04:41 kadoban joined
04:41 <thang1> Yeah, it just doesn't mean what I wanted it to mean
04:41 <thang1> It should've been tenaciousness lol
04:45 takle joined
05:02 takle joined
05:03 Mutter joined
05:06 <monochrom> algorithmic thinking
05:06 <thang1> ooh, nice one. I like it :)
05:07 <monochrom> In recent years there are two movements, one in the US one in the UK, by CS profs advocating that public compulsory education adds computing.
05:08 <thang1> I hope it doesn't happen
05:08 <monochrom> And by "add computing" they don't mean learn office suites and web page making. Nor do they really require everyone to code either. But to be able to appreciate algorithms.
05:09 <monochrom> In the US, this is headed by Jeane Wang. In the UK, SPJ.
05:09 <monochrom> And Jeane Wang coined the term "algorithmic thinking" for this.
05:09 <thang1> Or rather, I hope it does happen /after/ the education system is un-fucked. In the US, the education system is currently almost entirely beyond redemption; I'd be very fearful of any algorithmic thinking being crammed into the common core, and rigorous standardized testing
05:13 <thang1> Alright, I've procrastinated on my homework enough as it is. Time to get my act together
05:13 takle joined
05:16 <mniip> monochrom, is that the movement that teaches programming to 7 year olds
05:16 <monochrom> I don't know.
05:17 <mniip> a friend of mine has a child in school and
05:17 <mniip> [12:02:43] <christel> but i dunno, i am not sure what they do further on but in KS1 they learn about algorithms (how they are implemented as programs on digital devices, what the programs execute by following specific instructions etc), create and debug simple programs, learn to apply logical reasoning to predict the behaviour of simple programs, and learn bogstandard stuff like creating, organising, storing, manpula
05:17 <mniip> [12:02:49] <christel> ting and retrieving content, they learn about privacy and raising concerns re internet content and contact, etc.
05:19 <monochrom> I guess someone has to insert "concerns re Internet" somewhere, eh?
05:19 <monochrom> I mean, Conservatives are always eager to insert morality into sex education, too.
05:19 <mniip> of all things "concerns re internet" is a valid point
05:22 <mniip> monochrom, does algorithmic thinking include having no difficulty proving 2+2=4 from peano axioms?
05:22 <monochrom> Naw.
05:23 <mniip> I think it's quite relevant too
05:23 <monochrom> Well, maybe implicitly yes but they aren't going to do that directly.
05:23 <mniip> CH iso?
05:30 dni- joined
05:33 andyhoang joined
05:34 Kuros` joined
05:37 jbgi joined
05:39 takle joined
05:45 ThomasLocke joined
05:45 ThomasLocke joined
05:46 ali_bush joined
05:46 ali_bush joined
05:46 takle joined
05:47 cur8or joined
05:53 geekosaur joined
05:59 cschneid_ joined
06:02 eatman joined
06:07 galderz joined
06:07 takle joined
06:15 govg joined
06:26 Dance_ joined
06:29 haskelleksah joined
06:30 andyhoang joined
06:31 BOOKBOOK joined
06:33 Dance_ joined
06:51 takle joined
07:09 takle joined
07:12 cur8or joined
07:15 dni- joined
07:16 bvad joined
07:18 fluffystub joined
07:19 Pupnik joined
07:23 mattyw joined
07:26 takle joined
07:28 Levex joined
07:30 mounty joined
07:32 thc202 joined
07:34 Gurkenglas joined
07:34 mstruebing joined
07:34 merijn joined
07:37 comerijn joined
07:38 takle joined
07:41 Dance_ joined
07:50 takle joined
08:02 nickolay joined
08:09 takle joined
08:18 colt44 joined
08:19 grdryn joined
08:21 andyhoang joined
08:23 zero_byte joined
08:24 aarvar joined
08:27 slomo joined
08:27 slomo joined
08:30 Iceland_jack joined
08:33 bkboggy joined
08:37 ali_bush joined
08:42 colt44 joined
08:42 takle joined
08:45 takle joined
08:48 meandi joined
08:48 Levex joined
08:48 takle joined
09:26 nacon joined
09:26 nacon joined
09:28 superlinux joined
09:30 <superlinux> hi. In the visual studio code text editor, which is the most suitable extension for haskell editing?
09:38 govg joined
09:39 kritzcreek joined
09:43 fotonzade joined
09:51 Dance joined
09:52 vegai joined
09:56 <Akii> Line 26 is unfortunately wrong; I need `unionWith ??`: http://lpaste.net/355381
09:56 <Akii> however I don't find any way of implementing this
09:56 <Akii> because it kinda depends on what f is
09:57 <Akii> now that I've asked, maybe I need a newtype wrapper
09:57 <Akii> yeee that's probably it
09:59 viralstitch joined
10:01 <Akii> yup works :)
10:08 <Akii> and additionally I don't need any of this because I can just reduce the SubChanges as I go
10:08 <Akii> but was a fun excercise
10:14 takle joined
10:23 slomo joined
10:23 slomo joined
10:24 takle joined
10:24 andyhoang joined
10:25 takle joined
10:34 romank joined
10:39 conal joined
10:54 netheranthem joined
10:54 eacameron joined
10:54 conal joined
11:00 cschneid_ joined
11:07 Pupnik_ joined
11:14 eacameron joined
11:21 netheranthem joined
11:26 mengu joined
11:26 prophile joined
11:28 fbergmann joined
11:31 <LiaoTao> Top reason to love Haskell: 1. The Ackermann space heater technique has never been so simple to implement
11:31 <LiaoTao> s/reason/reasons
11:31 takle joined
11:33 takle joined
11:34 takle joined
11:35 <LiaoTao> merijn: I think I got the MyStateT implementation
11:35 <LiaoTao> Had to cheat a bit on >>=, though
11:36 <merijn> LiaoTao: Cheat? How?
11:36 <LiaoTao> Like, how to extract m (b,x) from the result of a-> MyStateT s m b
11:36 <LiaoTao> merijn: Check the solution
11:38 <LiaoTao> Didn't occur to me that you could just use runState
11:38 <LiaoTao> Like not at all
11:38 <merijn> :)
11:38 <merijn> Where's your solution?
11:39 <LiaoTao> mom
11:39 <LiaoTao> http://lpaste.net/355384
11:42 <merijn> LiaoTao: Ah...I spot a bug :)
11:42 <merijn> Have you tested the Applicative/Monad laws? :)
11:43 eacameron joined
11:43 <LiaoTao> merijn: Oh! The fun begins
11:43 <LiaoTao> Checking
11:44 <merijn> Suppose I define "constIncr x = modify (+1) >> pure x" so it increments the state and returns it's input
11:45 <merijn> LiaoTao: What would happen if I do "constIncr even <*> constIncr 2"?
11:45 takle joined
11:46 fbergmann joined
11:47 <LiaoTao> merijn: I'm not sure about constIncr
11:47 <LiaoTao> Doesn't ">>" imply that the result of modify (+1) isn't used?
11:47 <merijn> LiaoTao: Yes, but the *state* is
11:47 <LiaoTao> Oh!
11:47 <LiaoTao> So the state is modified, but the return value is ignored?
11:48 <LiaoTao> Which is logically the same as" >>=" for modify in particular?
11:48 <merijn> LiaoTao: Remember the regular MyState
11:49 <merijn> Or just <*> for MyState
11:49 <merijn> x >> y = x >>= \_ -> y
11:49 <merijn> But >>= (should) pass the state it gets first to x and then pass the new state to y, since it may have been modified
11:50 <LiaoTao> merijn: So my bug is in <*>?
11:51 <merijn> LiaoTao: There is a bug in <*> yes, but you may have made the same mistake elsewhere
11:51 <LiaoTao> merijn: I'm thinking it
11:51 takle joined
11:51 <LiaoTao> 's the (x, y) <- ma part
11:51 <LiaoTao> It should be (f, y), right?
11:51 <LiaoTao> Instead of (f, _), that is
11:52 andyhoang joined
11:52 <merijn> LiaoTao: How are you creating ma and mf?
11:53 <LiaoTao> By applying the respective state constructors to the input s
11:53 <merijn> LiaoTao: Are you sure that's what you should do?
11:54 <LiaoTao> Not at all
11:54 <LiaoTao> But I don't see why it should be any different than the regular MyState
11:54 <merijn> What your MyState implementation? Maybe that's buggy too :p
11:55 <LiaoTao> merijn: nitrix told me it was fine :(
11:55 <merijn> LiaoTao: Can you lpaste it?
11:55 <LiaoTao> omw
11:56 <LiaoTao> merijn: http://lpaste.net/355385
11:56 <merijn> Yeah, same bug :)
11:56 <LiaoTao> Blast
11:56 <merijn> LiaoTao: Try the following in ghci and see if you can figure it out
11:57 <merijn> "constExpr x = modify (+1) >> pure x" and then try running "myState (constExpr even <*> constExpr True) 0"
11:59 boris_rh joined
12:00 chlong joined
12:02 <LiaoTao> Is the pure implementation in MyState correct?
12:02 <LiaoTao> @merijn:
12:02 <lambdabot> Unknown command, try @list
12:02 <LiaoTao> Sorry lambdabot, not you
12:02 <merijn> pure is fine :)
12:03 <LiaoTao> merijn: And modify, too?
12:03 <merijn> Yeah
12:05 <merijn> eh, my example is wrong
12:05 <merijn> replace "True" with, like, 1
12:06 exferenceBot joined
12:06 <merijn> Did you run it?
12:06 <LiaoTao> merijn: Yeah, I just forgot the name of my constructor
12:07 <LiaoTao> Evaluates to (False, 1)
12:07 <merijn> LiaoTao: Is that what you'd expect?
12:08 <LiaoTao> merijn: It's supposed to be (True,1) ?
12:08 <merijn> The False bit is fine, but aren't we doing "modify (+1)" on both sides of <*> ? :)
12:09 <LiaoTao> Aha
12:09 <merijn> So why are we getting a resulting state of 1?
12:09 <LiaoTao> Missed that
12:10 eacameron joined
12:10 <* Akii> is doing this excercise as well, thanks!
12:11 govg joined
12:11 <merijn> LiaoTao: What's value are you matching with the wildcard on line 20?
12:12 <LiaoTao> merijn: I think I got it
12:13 <merijn> LiaoTao: There's a similar bug in your >>= implementation, can you spot it? :)
12:13 <LiaoTao> Yeah
12:13 <LiaoTao> *Main> myState (constExpr even <*> constExpr 1) 0
12:13 <LiaoTao> (False,2)
12:13 <merijn> :)
12:13 <LiaoTao> \o/
12:13 <Akii> I've a question
12:14 <merijn> Should be fairly straightforward to spot the same issue in MyStateT now
12:14 <Akii> you can evaluate `f` first, or `a`
12:14 Dance joined
12:14 <merijn> Akii: Eh, which 'f' and which 'a'? ;)
12:14 <Akii> lpaste is slow today
12:14 <Akii> http://lpaste.net/355386
12:14 <Akii> lines 4,5
12:14 <LiaoTao> merijn: http://lpaste.net/355387
12:15 <Akii> I could swap them and chain the initial state differently
12:15 eacameron joined
12:15 <Akii> which one is evaluated first and why
12:15 <Akii> (assuming this is correct)
12:15 <merijn> Akii: You mean, first pass the state to 'a' and then to 'f'?
12:15 <Akii> yes
12:16 <merijn> Akii: Congratulations, you have reinvented the really weird "reverse state" monad :)
12:16 <merijn> Akii: https://lukepalmer.wordpress.com/2008/08/10/mindfuck-the-reverse-state-monad/
12:16 <LiaoTao> That's the strangest thing I've ever seen wrt Haskell
12:17 <LiaoTao> Is that the one where he implements Conway's Game of Life?
12:17 <merijn> LiaoTao: Yeah, that one looks right to me, but to be sure you can try and see if you can prove the laws for it :)
12:20 toppler joined
12:22 takle joined
12:25 Big_G joined
12:25 <LiaoTao> merijn: http://lpaste.net/355390
12:25 <LiaoTao> Happy times
12:25 <LiaoTao> I'll go over the Monad laws now
12:25 <LiaoTao> Thanks a million for all the help
12:25 <LiaoTao> You're a great guy
12:26 <merijn> LiaoTao: Style note, you can indent after the do in <*> and not write like 80 columns to the right :)
12:26 <LiaoTao> Uh sure
12:26 <LiaoTao> Looks clean enough here though
12:27 <merijn> http://lpaste.net/355390
12:27 <merijn> I just personally dislike code waaaaaaaaay to the right :)
12:28 <LiaoTao> merijn: That looks better
12:28 <LiaoTao> Is there any way to have a line break directly inside a lambda?
12:29 <merijn> Any line break that is indented FURTHER than the previous layout is automatically treated as a continued line
12:29 <LiaoTao> Oh, that's nice
12:29 <merijn> LiaoTao: I'd recommend reading the details of how the layout rules work: https://en.wikibooks.org/wiki/Haskell/Indentation
12:29 <Dance> Hey guys, I'm interested in learning haskell, coming from a maths background
12:29 <Dance> anyone have reference suggestions?
12:30 <merijn> Dance: Honestly, mostly the same as for a non-maths background :p
12:31 <merijn> Despite popular internet rhethoric maths won't help you too much, especially at first, learning haskell
12:32 <Dance> ooh thats interesting, i guess it's more that i like reading things that are textbooky
12:32 TCZ joined
12:33 <merijn> The Haskell book is pretty decent
12:34 <LiaoTao> merijn: http://lpaste.net/355393
12:34 <LiaoTao> Final indentation edition
12:35 <Dance> thanks merijn, i'll look at that
12:35 <merijn> Looks about right, one more change you can make with recent GHC is remove the let in fmap
12:36 vmeson joined
12:36 <merijn> You could make it "first (\(x, y) -> (f x, y)) <$> p s"
12:36 <merijn> :t Data.Bifunctor.first
12:36 <lambdabot> Bifunctor p => (a -> b) -> p a c -> p b c
12:36 <merijn> eh
12:36 <merijn> Actually simpler
12:36 <merijn> "first f <$> p s" :)
12:36 <merijn> <$> fmap's throught the monad and "first f" applies 'f' to the left side of the tuple
12:37 <merijn> > first (+1) (2,True)
12:37 <lambdabot> (3,True)
12:37 <merijn> > first (+1) <$> Just (2,True)
12:37 <lambdabot> Just (3,True)
12:37 Dance joined
12:38 <merijn> So then it becomes "fmap f (MyStateT p) = MyStateT $ \s -> first f <$> p s"
12:38 <merijn> Or
12:38 <merijn> fmap f (MyStateT p) = MyStateT $ fmap (first f) . p
12:40 <LiaoTao> merijn: How do you import single functions from modules again?
12:41 <merijn> import Data.Bifunctor (first)
12:41 <LiaoTao> like 'import from ...' or w/e
12:41 <LiaoTao> Aha
12:41 <LiaoTao> thanks
12:45 <LiaoTao> merijn: While you're here, could you perhaps explain the powerset function from LYAH?
12:45 <LiaoTao> powerset xs = filterM (\x -> [True, False]) xs
12:45 <LiaoTao> I _really_ don't understand it
12:45 Pupnik joined
12:47 <Iceland_jack> LiaoTao: Do you know the list monad?
12:47 <LiaoTao> Vaguely
12:48 <Iceland_jack> At a bird's eye view, the Monad instance of lists models non-determinism
12:48 eacameron joined
12:49 <Iceland_jack> Regular 'filter' uses a predicate (a -> Bool) to decide which elements to keep (True) or drop (False)
12:49 <LiaoTao> Iceland_jack: That doesn't really help me in understanding
12:49 govg joined
12:49 <LiaoTao> That's what the book tells you, but there's a lot of handwaving
12:49 <Iceland_jack> In the case of filterM it 'forks' the universe for ever element
12:49 <Iceland_jack> Both keeping it, and dropping it
12:50 <LiaoTao> Iceland_jack: Generally, or just for the anonymous function in powerset?
12:50 <Iceland_jack> If you want more details there are many resources online that explain it nicely, if you search for "filterM" "[True,False]" you'll find them
12:51 <LiaoTao> Right
12:51 <Iceland_jack> Well in the case of (\_ -> [a, b]) it forks the universe into 2 for every element
12:53 <LiaoTao> Iceland_jack: But the a and b must both be bools, right?
12:53 <Iceland_jack> yeah
12:54 <Iceland_jack> filterM (\case 'a' -> [True]; _ -> [False]) "abca"
12:54 <Iceland_jack> filterM (\case 'a' -> [True,False]; _ -> [False]) "abca"
12:54 <Iceland_jack> oops
12:54 <Iceland_jack> > filterM (\case 'a' -> [True]; _ -> [False]) "abca"
12:54 <lambdabot> ["aa"]
12:55 <Iceland_jack> Here we always keep the 'a' element (True), drop all others (False)
12:55 <Iceland_jack> > filterM (\case 'a' -> [True,False]; _ -> [False]) "abca"
12:55 <lambdabot> ["aa","a","a",""]
12:55 <LiaoTao> Iceland_jack: Took me a while to parse that
12:55 <Iceland_jack> Here we keep (True) -AND- drop (False) the 'a' element
12:55 <LiaoTao> Didn't know you could do that kind of pattern matching
12:55 <Iceland_jack> It uses the LambdaCase extension, let me rewrite it
12:56 <Iceland_jack> > filterM (\ch -> if 'a' == ch then [True,False] else [False]) "abca"
12:56 <lambdabot> ["aa","a","a",""]
12:56 <Iceland_jack> A more interesting predicate is 'even :: Int -> Bool'
12:56 <Iceland_jack> > filterM (\n -> if even n then [True,False] else [False]) [1,2,3,4]
12:56 <lambdabot> [[2,4],[2],[4],[]]
12:57 <Iceland_jack> Note the difference when we reverse [True,False]
12:57 <Iceland_jack> > filterM (\n -> if even n then [False,True] else [False]) [1,2,3,4]
12:57 <lambdabot> [[],[4],[2],[2,4]]
12:57 <LiaoTao> This is moving a bit too quickly, I'll read it again from the start
12:59 eacameron joined
12:59 <LiaoTao> Logically, I think I understand what it does now
12:59 <LiaoTao> But the order of computation/evaluation is very fuzzy
12:59 <Iceland_jack> Yeah
13:00 <LiaoTao> i.e. Why does "aa" come first?
13:00 <Iceland_jack> LiaoTao: This is not what 'normal' Haskell code looks like
13:01 <Iceland_jack> people like this example because it's cute, and a testament to the power of the Monad abstraction
13:02 <Iceland_jack> LiaoTao: You can think of [True,False] as instructions to an employee at a conveyor belt
13:04 <LiaoTao> Iceland_jack: Perhaps it would help to know how the state is maintained through to the end
13:05 <Iceland_jack> It all happens through the list monad, I would say to familiarise yourself with that
13:05 <LiaoTao> Okay
13:05 <Iceland_jack> or the Applicative []
13:05 <Iceland_jack> > liftA2 (,) [1,2,3] "abc"
13:06 <lambdabot> [(1,'a'),(1,'b'),(1,'c'),(2,'a'),(2,'b'),(2,'c'),(3,'a'),(3,'b'),(3,'c')]
13:06 eacameron joined
13:06 <Iceland_jack> > [ (a, b) | a <- [1,2,3], b <- "abc" ]
13:06 <lambdabot> [(1,'a'),(1,'b'),(1,'c'),(2,'a'),(2,'b'),(2,'c'),(3,'a'),(3,'b'),(3,'c')]
13:07 jathan joined
13:07 mstruebing joined
13:10 <LiaoTao> Iceland_jack: That's indeed where the problem lies
13:10 <LiaoTao> I'll go read on it right now
13:10 <Iceland_jack> Good luck
13:10 <LiaoTao> Thanks a lot for the explanations!
13:10 <Iceland_jack> No problem, hope it helped
13:10 <Iceland_jack> the important thing to note is that complicated behaviour comes from -SIMPLE- behaviour
13:12 guampa joined
13:13 <Iceland_jack> The monad instance for lists is very simple!
13:13 <Iceland_jack> return a = [a]
13:13 <Iceland_jack> join = concat
13:13 <Iceland_jack> (>>=) = concatMap
13:13 <Iceland_jack> (with arguments flipped)
13:15 <LiaoTao> I think I'll write my own list implementation and see where the magic is
13:16 <Iceland_jack> Exactly
13:16 <Iceland_jack> Define your own list type, maybe even define your own Monad type class as well
13:16 <Iceland_jack> Define your methods as regular functions first if you have the time
13:16 <Iceland_jack> myReturn :: a -> [a]
13:16 <Iceland_jack> myReturn a = [a]
13:17 <Iceland_jack> (return is like 0 for addition, it does "nothing")
13:18 <Iceland_jack> so if lists "fork the universe", return forks it into a single universe.. i.e. not at all
13:18 <Iceland_jack> So every time I wrote [False] or [True] I could have written (return False), (return True)
13:19 <LiaoTao> Yeah, that's the easy part
13:19 <Iceland_jack> join just flattens a list
13:19 <Iceland_jack> :t join :: [[a]] -> [a]
13:19 <lambdabot> [[a]] -> [a]
13:19 wei2912 joined
13:19 <Iceland_jack> > join ["hello", " ", "world", "!"]
13:19 <lambdabot> "hello world!"
13:19 <LiaoTao> That, too I understand
13:20 <LiaoTao> +,
13:20 <Iceland_jack> map maps over a list
13:20 <Iceland_jack> and that's all
13:20 <Iceland_jack> > map toUpper "Hello World"
13:20 <lambdabot> "HELLO WORLD"
13:20 Guest37310 joined
13:21 iAmerikan joined
13:21 <Iceland_jack> LiaoTao: You can define (>>=) in terms of join / return
13:21 <Iceland_jack> in terms of join / fmap
13:21 <Iceland_jack> So if you understand concat and map, you understand concatMap
13:22 <Iceland_jack> (if you understand join and fmap, you understand (>>=))
13:22 <Iceland_jack> https://en.wikibooks.org/wiki/Haskell/Understanding_monads#Monads_and_Category_Theory for more info
13:23 cschneid_ joined
13:23 `micro joined
13:26 <LiaoTao> Iceland_jack: Should I go about this like first defining the Monoid instance, then Functor and lastly Monad?
13:26 <Iceland_jack> The Monoid instance is separate from Functor / Applicative / Monad
13:27 <Iceland_jack> First you would define your own list data type: data List a = Nil | Cons a (List a)
13:27 <LiaoTao> Don't you need mconcat to implement join?
13:27 <Iceland_jack> You don't need it no
13:27 <Iceland_jack> but they are the same
13:28 iAmerikan joined
13:28 <Iceland_jack> Good things can be defined in many equivalent ways :)
13:28 carlomagno1 joined
13:33 geekosaur joined
13:36 pbrant joined
13:39 superlinux left
13:43 takle joined
13:46 takle joined
13:49 crave joined
13:49 guampa joined
13:53 takle_ joined
13:55 Dance joined
13:59 takle joined
14:03 <nitrix> join is the same as mconcat, in the sense that in both case you still have a monoid, excepted for monads, your monoid is of an endofunctor. Don't worry, you're not expected to know that :P
14:03 <nitrix> But it's not surprising that you see a similarity :)
14:07 <nitrix> LiaoTao: I haven't looked throughly at your implementation the other day, I just made sure you were on the right track. I could have a closer look or you could try proving the laws :)
14:08 madjestic joined
14:11 <nitrix> A proof needs not be complicated and mathematical; with the type checker to help you and the Curry-Howard correspondence, your program is in itself works as a proof.
14:12 <nitrix> If you begin with Functor, you have two laws to sastisfy:
14:12 <nitrix> (1) fmap id == id
14:12 <nitrix> (2) fmap (f . g) == (fmap f . fmap g)
14:13 jathan joined
14:17 <nitrix> LiaoTao: The first law verifies that the transformation done by the functor wont affect its structure. For example, if I'm doing `fmap (+1)` on a list [1..], yes the elements are all going to be incremented by one, but I wont have more or less elements, since the structure cannot be modified. [] has to stay.
14:19 <LiaoTao> nitrix, I think I understand the laws quite well
14:19 <LiaoTao> Not necessarily their theoretical foundation, but well enough to see how to check them
14:19 <LiaoTao> Thank you for the explanation
14:20 <nitrix> In our case, it'd mean that some stateful function of type `s -> m (a, s)`, say `\s -> return (undefined, s)`, can ...
14:20 <nitrix> Oh :P
14:22 <nitrix> Iceland_jack: Is there a way to specify how the type of the member of a type class gets specialized in an instance?
14:22 <nitrix> Iceland_jack: -- fmap ~ (a -> b) -> (MyStateT s m) a -> (MyStateT s m) b
14:22 <Iceland_jack> Yes
14:22 <Iceland_jack> InstanceSigs
14:22 <Iceland_jack> I recommend it forever and always
14:22 seangrove joined
14:23 chlong joined
14:23 <merijn> InstanceSigs <3
14:24 <toppler> Never heard of it!
14:24 <toppler> If you want to take the opportunity to explain its awesomeness, I'm all ears.
14:24 yellowj joined
14:25 <merijn> toppler: Basically, "writing type signature in a typeclass instance is no longer an error"
14:25 <Iceland_jack> toppler: The most basic usefulness is the same as top-level type signatures
14:25 <merijn> toppler: Normally you're not allowed to include type signatures in instances
14:25 <Iceland_jack> which are universally recommended
14:26 <Iceland_jack> With even greater usefulness when using type families (especially when they are associated to superclasses, possibly in other modules: no way I want to keep that in my head)
14:26 <toppler> thanks!
14:27 <Iceland_jack> It helps me personally when using infix type operators
14:27 <Iceland_jack> considerably
14:28 <Iceland_jack> or any method with constraints / more than 3 type variables
14:29 <nitrix> I would've expected the type checker to actually expect the specialized type in the instance declaration rather than the general one.
14:30 <Iceland_jack> What do you mean?
14:30 <toppler> Do you have an example not using other GHC extensions?
14:30 <nitrix> I don't know if Haskell is to blame or GHC for this.
14:30 <Iceland_jack> toppler: Example of using InstanceSigs?
14:31 <Iceland_jack> instance Functor Maybe where fmap :: (a -> a') -> (Maybe a -> Maybe a'); fmap _ Nothing = Nothing; fmap f (Just x) = Just (f x)
14:31 <toppler> Iceland_jack: nvm
14:31 <Iceland_jack> too late ;)
14:31 <toppler> Gotcha.
14:31 <nitrix> Iceland_jack: The instance HAS to implement that method for that given type, so naturally, it's an ad-hoc process that can only lead to you implementing a specialized version of `fmap` for example, so I'm really surprised GHC's type checker / Haskell doesn't recognise this.
14:33 <Iceland_jack> It's still not clear what you mean, the type can be more general in fact
14:33 <Iceland_jack> If you have: class F a where f :: a -> a
14:33 <Iceland_jack> you can write: instance F Int where f :: a -> a; f = id
14:33 govg joined
14:33 <glguy> are you sure that's still the case?
14:33 <Iceland_jack> It may have changed
14:33 <Iceland_jack> It's different in 7.8 and 8
14:34 <glguy> something changed in 8
14:34 <Iceland_jack> it may have changed again in 8.2
14:34 <nitrix> Iceland_jack: Oh, if that's the case, then it makes sense that the type signature breaks.
14:34 <glguy> so that it had to match the class
14:34 <Iceland_jack> hm
14:34 <nitrix> Iceland_jack: If not, then I'd expect people to be able to give specialized types without InstanceSigs.
14:34 <nitrix> Let me try c:
14:35 <glguy> oh i bet I'm thinking of default signatures
14:35 <Iceland_jack> ah right
14:36 <nitrix> That compiles.
14:36 <Iceland_jack> Btw asked a question on /r/haskell if anyone has feedback https://www.reddit.com/r/haskell/comments/6ac1x2/idealised_monads_or_monad_instance_for_lift_f/
14:36 <nitrix> I'm susrprised to see `f :: a -> a` completely refused though. You're not allowed any type signature in there ._.
14:36 <nitrix> Even when the general one is legal.
14:37 <glguy> that's the point of the extension
14:37 <glguy> to allow signatures in instances
14:37 <nitrix> glguy: Could've Haskell took a more ehm.. principled approach?
14:37 rstefanic joined
14:38 <Iceland_jack> iirc InstanceSigs started as a quick hack by spj
14:38 <nitrix> Similar to how top-level declarations are figured out?
14:38 <Iceland_jack> doesn't even resolve type families in 7.8
14:38 <glguy> nitrix, I don't know what you're getting at
14:38 <Iceland_jack> (which is what we use at work, which reminds me I should get to work)
14:40 <nitrix> glguy: You're able to write specialized versions of general functions easily; e.g. `map = fmap` and the type annotation doesn't make the type checker trip; that's definitely intended, so why the oversight when it comes to classes? It's not like type classes were an afterthought.
14:40 <glguy> what oversight?
14:41 <nitrix> A language design oversight.
14:41 <glguy> what's the code you wanted to write that you can't due to this"oversight"?
14:42 <nitrix> glguy: Type annotations that requires the use of the extension InstanceSigs instead of being part of the language.
14:43 <nitrix> Why does type classes, which is just some glorified ad-hoc polymorphism really, complicate the matter?
14:43 <nitrix> Other functions can do this fine.
14:43 <glguy> without any other extensions those signatures are completely redundant
14:43 <glguy> the signature is found in the class definition
14:44 <glguy> so the syntax is simply such that signatures go in classes, implementations go in instances
14:44 <nitrix> I guess, but the instances are independent. They're standalone functions with their own appropriate type which are all part of this ad-hoc mechanism.
14:44 <glguy> ok
14:45 <nitrix> Doesn't it seems like an oversight to you D: ?
14:45 <Iceland_jack> nitrix: You're just asking why InstanceSigs isn't part of the core language?
14:46 <nitrix> More like, why we came to need InstanceSigs in the first place. How did we "miss" that functions participating in this ad-hoc polymorphism system that are the type classes, want their own type signatures.
14:48 fotonzade joined
14:51 uglyfigurine joined
14:52 <geekosaur> afaik it's only when you start using generics for pseudo-"automatic" deriving of instances that it becomes a thing?
14:54 <nitrix> Sorry if that seems like an odd question. I realise I ask a lot of odd questions, but I'm doing language design too so these "questionable quirks" fascinates me :P
14:54 <nitrix> We can move on and I wouldn't mind x]
14:55 <Iceland_jack> I like my questions like my numbers, odd
14:56 <geekosaur> so, in a certain sense, when we started using Generics to provide default implementations for some typeclasses, we needed to be able to say that the default implementation had constraints (like Generic) that specific implementations didn't need
14:56 <geekosaur> er
14:57 <geekosaur> I switched gears there
14:57 <geekosaur> in a certain sense, we are abusing the typeclass mechanism when we do that
14:57 <geekosaur> InstanceSigs supports that abuse
14:57 <glguy> that's default sigs
14:58 <geekosaur> hm. maybe I should have coffee first <,<
14:58 <Sornaensis> coffee is required for waking life
14:58 <* Iceland_jack> is dead, apparently
14:58 <Sornaensis> minimum dosage for me is ~2.5gallons
14:59 <geekosaur> not for me usually but I have started today with a massive headache and some sensory hypersensitivity. coffee could push that either direction so I tend to hold off initiallly...
15:00 <geekosaur> oh, right. it's a hack to allow ScopedTypeVariables in instances
15:02 <geekosaur> the language was not designed for scoped type variables. this is one of the indications that just making them default behavior as some would prefer is not necessarily a good idea; it has odd knock-on effects
15:04 cschneid_ joined
15:07 nacon joined
15:07 nacon joined
15:08 c4r50nz joined
15:11 govg joined
15:20 <rstefanic> Not directly a haskell question, but it's related. In order for something to be associative, does it also have to be commutative? Because the associative property is saying that it doesn't matter how things are grouped (or associated). But in order for that to be true, then it'd have to be commutative, correct?
15:20 <Iceland_jack> rstefanic: No, a simple example is lists
15:20 <Iceland_jack> concatenating lists is associative
15:20 <Iceland_jack> but ("hi" ++ "bye") /= ("bye" ++ "hi")
15:22 <Iceland_jack> Same with functions that return the first or second argument:
15:22 <Iceland_jack> a <. _ = a
15:22 <Iceland_jack> _ .> b = b
15:22 <LiaoTao> @src filterM
15:22 <lambdabot> Source not found. I don't think I can be your friend on Facebook anymore.
15:22 <Sornaensis> :t filterM
15:22 <lambdabot> Applicative m => (a -> m Bool) -> [a] -> m [a]
15:23 <Iceland_jack> LiaoTao: https://hackage.haskell.org/package/base-4.9.1.0/docs/Control-Monad.html#v:filterM
15:23 <Iceland_jack> Source: https://hackage.haskell.org/package/base-4.9.1.0/docs/src/Control.Monad.html#filterM
15:23 <LiaoTao> Thanks
15:23 <Iceland_jack> LiaoTao: That implementation is very obfuscated though
15:24 <Iceland_jack> Consider a simpler version, like the original in the Haskell Report: https://www.haskell.org/onlinereport/monad.html
15:25 <rstefanic> Iceland_jack: I see. So in the case of ("hello" ++ "hi" ++ "morning"), it's associative because you could group "hi" and "morning" first, and then "hello" and "himorning", but it's not commutative because the order matters in this case.
15:26 <LiaoTao> That's a lot more readable
15:26 Iceland_jack joined
15:26 <Sornaensis> oh
15:26 <Sornaensis> applicative
15:27 <Sornaensis> I saw 'm' and immediately read 'Monad'
15:27 <Iceland_jack> It used to be
15:27 <Sornaensis> in the original report it was
15:27 <LiaoTao> I suppose I don't understand "b <- p x" when p x = [Bool]
15:27 <Sornaensis> why don't we have applicative do :P
15:27 <Iceland_jack> We do Sornaensis
15:27 <Iceland_jack> https://ghc.haskell.org/trac/ghc/wiki/ApplicativeDo
15:27 <* Sornaensis> brainsplosion
15:27 <Iceland_jack> LiaoTao: Do you know how do-notation desugars?
15:28 <Iceland_jack> That may be the 'missing link' for you
15:28 <LiaoTao> That may be it
15:28 <Iceland_jack> If you understand the building blocks (join, fmap, return, (>>=), ...)
15:29 <Iceland_jack> > do a <- [1,2,3]; return (show a)
15:29 <lambdabot> ["1","2","3"]
15:29 <Iceland_jack> This gets transformed into:
15:29 <Iceland_jack> @undo do a <- [1,2,3]; return (show a)
15:29 <lambdabot> [1, 2, 3] >>= \ a -> return (show a)
15:29 <Iceland_jack> Which for lists is:
15:29 <Iceland_jack> > concatMap (\a -> return (show a)) [1,2,3]
15:29 <lambdabot> ["1","2","3"]
15:30 <Iceland_jack> And recall that (return a = [a])?
15:30 <Iceland_jack> > concatMap (\a -> [show a]) [1,2,3]
15:30 <lambdabot> ["1","2","3"]
15:33 <LiaoTao> >concatMap (\a -> [show a, show 5]) [1,2,3]
15:34 <Iceland_jack> (you need a space after '>')
15:34 <LiaoTao> > concatMap (\a -> [show a, show 5]) [1,2,3]
15:34 <lambdabot> ["1","5","2","5","3","5"]
15:34 <LiaoTao> Suspected as much
15:34 <LiaoTao> Right, I think I understand now
15:34 <Sornaensis> > [y | x <- [1..6], y <- (return . show) x]
15:34 <lambdabot> ["1","2","3","4","5","6"]
15:35 <glguy> ApplicativeDo came in handy recently for me for building up a self-documenting configuration file parser
15:36 <Iceland_jack> ApplicativeDo (or rather FunctorDo) is great for building lenses
15:36 <Iceland_jack> much nicer than fmap / <&>
15:36 <Sornaensis> FunctorDo?
15:37 <Iceland_jack> Sornaensis: I made up the name, but if you use ApplicativeDo and it only requires a Functor constraint
15:38 <Sornaensis> does it keep the resultant expression in the functor context?
15:38 <Iceland_jack> Let's you write
15:38 <Sornaensis> FunctorDo { x <- f; g x } `g x` is f b ?
15:38 <Iceland_jack> ?
15:38 <Iceland_jack> _1 f (a, b) = do
15:38 <Iceland_jack> a' <- f a
15:38 <Iceland_jack> pure (a', b)
15:39 <Sornaensis> how does pure work w.o an applicative instance
15:39 rembo10 joined
15:39 <Iceland_jack> Sornaensis: 'fmap f xs' can be defined as (do x <- xs; pure (f x))
15:40 <Iceland_jack> so anything of that pattern can be given a Functor constraint
15:40 <glguy> Sornaensis: It's a bit of a hack, pure isn't actually used
15:40 <glguy> It operates at the syntax level
15:40 <Sornaensis> not use?
15:40 <Sornaensis> used?
15:41 <Iceland_jack> Sornaensis: Just like ApplicativeDo lets you use 'return' and '>>=' without a Monad constraint
15:41 <glguy> Like you write 'pure' in applicativedo notation, but then the notation is desugared not to have the pure
15:41 <Sornaensis> what habbins to pure
15:41 <Sornaensis> it just turns the whole thing into fmap?
15:41 <geekosaur> think of it as a RULES pragma that recognizes the pattern and rewrites it as fmap, ye
15:41 <Sornaensis> ah
15:42 <Sornaensis> seems like it could get confusing writing syntax that gets erased lol
15:43 mizu_no_oto_work joined
15:44 <Sornaensis> geekosaur: can you explain the pattern or is there someplace that explains it?
15:44 <glguy> Sornaensis: try typing ApplicativeDo into the GHC users guide search box
15:44 <glguy> That's your starting point for understanding any GHC extension
15:45 MotherFlojo joined
15:45 <geekosaur> yeh. in this case, I think as soon as you start digging the RULES analogy (where a pattern is just a type signature) breaks down, because ApplicativeDo is a bit more introspective about what's going on
15:46 <Iceland_jack> Sornaensis: A paper was pubished about it, if that's what you're into: http://simonmar.github.io/bib/papers/applicativedo.pdf
15:46 <geekosaur> you do want to read the details of how ApplicativeDo works, because it has some weird gotchas due to needing to recognize certain code patterns in order to rewrite them into something that works
15:48 <MarcelineVQ> especially for people prone to use $
15:49 <Iceland_jack> MarcelineVQ: That's how I light my cigars
15:49 <glguy> MarcelineVQ: I think there's a special case (now?) for $
15:49 <MarcelineVQ> there very well may be since it's absent from the gotchas section now
15:51 kykim joined
15:51 <Sornaensis> Iceland_jack: thanks
15:53 ski joined
16:02 iAmerikan joined
16:06 delexi joined
16:10 ski joined
16:13 meandi_2 joined
16:33 carlomagno joined
16:50 Gurkenglas joined
16:52 acarrico joined
16:54 pilne joined
16:59 iAmerikan joined
17:02 fotonzade joined
17:15 slomo joined
17:15 slomo joined
17:17 ski joined
17:19 mounty joined
17:24 iAmerikan joined
17:42 ski joined
17:58 uglyfigurine joined
18:11 fotonzade joined
18:15 ski joined
18:20 albertus1 joined
18:20 iAmerikan joined
18:48 ski joined
19:01 MotherFlojo joined
19:03 salios joined
19:05 cannibalbob joined
19:13 mstruebing joined
19:23 takle joined
19:23 ski joined
19:24 mengu joined
19:27 deank joined
19:29 takle joined
19:33 MotherFlojo joined
19:41 iAmerikan joined
19:50 viralstitch joined
19:56 madjestic joined
19:58 ski joined
20:01 Levex joined
20:07 Gurkenglas joined
20:10 Hjulle joined
20:17 iAmerikan joined
20:18 efm joined
20:31 dni-_ joined
20:41 ski joined
20:44 taksuyu joined
20:55 pbrant joined
20:56 juanpaucar joined
21:05 MotherFlojo joined
21:15 zero_byte joined
21:15 madjestic joined
21:18 ski joined
21:20 efm joined
21:32 MotherFlojo joined
21:35 cannibal_ joined
21:47 uglyfigurine joined
21:51 fotonzade joined
21:52 hiratara joined
21:58 patbecich joined
22:01 romank joined
22:04 ski joined
22:10 ski joined
22:10 JoelleVanDyne joined
22:12 iAmerikan joined
22:15 NoCreativity joined
22:18 Levex joined
22:21 romank joined
22:25 conal joined
22:27 albertus1 joined
22:30 juanpauc_ joined
22:32 patbecich joined
22:34 dni- joined
22:36 uglyfigurine joined
22:42 aarvar joined
22:48 Zialus joined
22:49 romank joined
22:51 ski joined
22:53 MotherFlojo joined
23:02 juanpaucar joined
23:04 mcglk joined
23:06 louispan joined
23:11 romank joined
23:11 patbecich joined
23:15 MotherFlojo joined
23:18 meandi joined
23:19 carlomagno joined
23:22 Levex joined
23:24 conal joined
23:26 romank joined
23:30 MotherFlojo joined
23:34 mengu joined
23:37 ski joined
23:38 fotonzade joined
23:46 louispan joined
23:49 g0d355__ joined
23:51 patbecic` joined
23:53 alasi joined
23:54 mengu joined