<    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 24 25  
26 27 28 29 30 31
00:02 Pupnik joined
00:14 jmiven joined
00:22 ali_bush joined
00:22 ali_bush joined
00:24 eacameron joined
00:26 sdlnv joined
00:26 animated joined
00:35 peterbec` joined
00:36 <parsnip> > convert (read "1488572493" :: Int) :: POSIXTime
00:36 <lambdabot> error:
00:36 <lambdabot> Not in scope: type constructor or class ‘POSIXTime’
00:36 <parsnip> > import Data.Time.Clock.POSIX
00:36 <lambdabot> <hint>:1:1: error: parse error on input ‘import’
00:37 poohflapz joined
00:40 <parsnip> > minBound :: Int
00:40 <lambdabot> -9223372036854775808
00:42 <parsnip> posixSecondsToUTCTime (convert (maxBound :: Int) :: POSIXTime) ==> 292277026596-12-04 15:30:07 UTC
00:42 <parsnip> should be safe ;)
00:43 malaclyps joined
00:45 meandi joined
01:09 peterbec` joined
01:15 eacameron joined
01:16 mengu joined
01:20 mengu_ joined
01:25 mengu joined
01:28 joneshf-laptop joined
01:37 mengu joined
01:38 eacameron joined
01:42 \Mike joined
01:43 eacameron joined
01:44 peterbec` joined
01:58 seagreen joined
02:00 hphuoc25 joined
02:02 texasmynsted joined
02:14 mounty joined
02:18 conal joined
02:22 conal joined
02:23 uglyfigurine joined
02:30 <parsnip> s/convert/fromIntegral/
02:31 mengu joined
02:40 jorris joined
02:48 <mounty> dmj` or anyone else who knows: you mentioned hydra and nixos in the context of setting up a CI server. Is it the case that if I were to use nixos, I could publish a simple 'recipe' and that would be enough to enable anyone else to set up a CI server just like mine?
02:49 <mounty> ... including installing and configuring Stack, Postgres and PhantomJS ?
02:50 <dmj`> mounty: pretty much
02:50 peterbec` joined
02:51 <mounty> OK, Zounds good. Thanks.
02:58 hphuoc25 joined
03:21 peterbec` joined
03:37 exferenceBot joined
03:39 hexagoxel joined
03:45 fred-fri joined
03:45 <peterbec`> Hello, I'm using this `choice` combinator from the Trifecta parsing library: https://hackage.haskell.org/package/parsers-0.12.4/docs/Text-Parser-Combinators.html#v:choice
03:46 <peterbec`> In the second example in this IO, I'm expecting a success: https://github.com/peterbecich/haskell-programming-first-principles/blob/master/src/LearnParsers.hs#L126-L144
03:47 <peterbec`> Instead, it fails. The oneTwoThreeS parser should fail but I was expecting the oneTwoS parser to succeed, through choice. The unexpected output is in the comments. Can someone straighten out my understanding of `choice`? thank you
03:47 <fred-fri> would much appreciate any feedback of how to make this solution to "the staircase problem" shorter, clearer and more elegant: https://gist.github.com/androidfred/51116c056d790c354554f253f87d33a6
04:01 eacameron joined
04:11 zeh joined
04:12 trudyjane joined
04:17 <MarcelineVQ> peterbec`: using 'try' will fix this but I'm not quite sure what's going on entirely. seems to do with when a parser starts to succeed and fails. here a parser that fails without matching any input won't cause the problem but one that starts to match and fails will
04:18 <MarcelineVQ> e.g. parse (choice [some (char '2'), some (char 'z'), oneTwoS]) "12" vs parse (choice [some (char '1') >> some (char 'z'), oneTwoS]) "12"
04:20 kadoban joined
04:28 DataComputist joined
04:37 DataComputist joined
04:43 <peterbec`> MarcelineVQ: you've broken down the problem wonderfully. Thanks.
04:44 <peterbec`> I wouldn't have noticed that
04:46 nokomo joined
04:47 <peterbec`> and yes, you're correct, `try` on each element of the list passed tho `choice` fixed it. Thanks. I'll try and understand what's going on tomorrow.
04:50 aarvar joined
04:58 IRCFrEAK joined
05:05 eacameron joined
05:11 harfangk joined
05:16 uglyfigurine joined
05:25 <qmm> Given the following definition of f, what is the type of f True?
05:25 <qmm> f :: a -> a
05:25 <qmm> f x = x
05:25 <qmm> f True :: Bool
05:25 <qmm> or
05:26 <qmm> f True :: a
05:26 <qmm> it returns a Bool
05:26 <qmm> i guess it is f True :: Bool
05:29 <glguy> Yes, f True :: Bool
05:33 jorris joined
05:59 fred-fri joined
06:02 meandi_2 joined
06:16 aarvar joined
06:16 hexagoxel joined
06:21 splanch joined
06:37 takle joined
06:45 splanch joined
06:51 hexagoxel joined
06:56 takle joined
06:57 splanch joined
07:07 mengu joined
07:13 takle joined
07:23 peterbec` joined
07:23 hexagoxel joined
07:32 takle joined
07:33 miiko24 joined
07:35 <miiko24> howdy folks, a newbie here, can someone explain to me what is the importance of reader monad, isn't it basically just a wrapper around a function? isn't it enough to pass function around? what am i missing here?
07:42 splanch joined
07:58 hexagoxel joined
08:00 takle joined
08:05 simendsjo joined
08:08 takle joined
08:16 takle joined
08:26 justicefries joined
08:29 hexagoxel joined
08:39 takle joined
08:39 owiecc joined
08:41 Rizy joined
08:58 owiecc joined
09:01 nacon joined
09:13 gregman_ joined
09:13 t0by joined
09:21 curious_corn joined
09:23 Durz0 joined
09:24 hvr joined
09:24 hvr joined
09:24 peterbec` joined
09:32 hexagoxel joined
09:33 takle joined
09:34 splanch joined
09:41 takle joined
09:43 thc202 joined
09:44 curious_corn joined
09:48 takle joined
09:54 uglyfigurine joined
09:56 takle joined
10:01 takle joined
10:18 hexagoxel joined
10:21 eacameron joined
10:22 takle joined
10:26 peterbec` joined
10:30 takle joined
10:46 reptar_ joined
10:48 takle joined
10:49 <reptar_> how can i access the head and tail of a and b? (x:xs) http://lpaste.net/666239458714058752
10:53 exferenceBot joined
10:55 delexi joined
10:56 takle joined
10:57 Gloomy joined
10:59 takle joined
11:02 Nikotiini joined
11:08 <reptar_> i figured it out, i think :)
11:08 <reptar_> so nvm
11:09 Pupnik_ joined
11:10 kritzcreek_ joined
11:15 hexagoxel joined
11:22 grayjoc joined
11:29 yellowj joined
11:33 hphuoc25 joined
11:35 Gurkenglas joined
11:37 Uniaika joined
11:45 Nikotiini joined
11:54 wildlander joined
11:54 wildlander joined
11:55 wildlander joined
11:58 wildlander joined
12:09 wei2912 joined
12:10 hexagoxel joined
12:12 splanch joined
12:23 hvr joined
12:23 hvr joined
12:24 peterbec` joined
12:28 shadowPriest joined
12:30 splanch joined
12:31 nil_ joined
12:33 albertus1 joined
12:46 <nil_> If someone feels like playing I'm Thinking of a Typeclass, I'll be available once I get back with the groceries (15 minutes)!
12:55 Gurkenglas_ joined
13:13 eacameron joined
13:21 contiver joined
13:24 curious_corn joined
13:25 peterbec` joined
13:37 Cthalupa joined
13:40 jorris joined
13:42 delexi joined
13:46 splanch joined
13:47 simendsjo joined
13:47 simendsj` joined
13:49 simendsjo joined
13:52 Cthalupa joined
13:53 mengu joined
13:57 eacameron joined
13:57 stef204 joined
14:02 hphuoc25 joined
14:04 eacameron joined
14:05 jorris joined
14:26 peterbec` joined
14:32 eacameron joined
14:38 zerokarmaleft joined
14:41 marvin2 joined
14:54 nacon joined
14:54 nacon joined
15:10 <reptar_> what is "I'm thinking of a type class?"
15:11 bling5630 joined
15:15 simendsjo joined
15:19 Gurkenglas_ joined
15:31 \Mike joined
15:32 uglyfigurine joined
15:40 smichel17 joined
16:02 aarvar joined
16:09 Nik05 joined
16:09 shayan_ joined
16:10 Zialus joined
16:16 takle joined
16:16 tangled_z joined
16:16 eacameron joined
16:16 <tangled_z> hi, I'm having trouble adding a package to stack that needs to be installed from github
16:16 <tangled_z> i get this error: https://gist.github.com/anonymous/e1e4957c6db31991dac787f3e7fa3882
16:18 shadowPriest joined
16:27 peterbec` joined
16:33 uglyfigurine joined
16:42 conal joined
16:44 jrajav joined
16:50 texasmynsted joined
16:56 albertus1 joined
16:58 mimi_vx_ joined
16:59 takle joined
17:04 Gurkenglas_ joined
17:07 takle joined
17:18 shadowPriest joined
17:20 takle joined
17:24 Zialus joined
17:26 <\Mike> I'm working on Chris Allen's book, and get stuck at an exercise where I'm to write my own version of any, point-free. I get as far as to myAny = \t -> or . (map t) but I don't know how to continue, to transform this such that I can drop the last lambda. Any hints?
17:38 nil_ joined
17:39 <nil_> What's the most elegant way to flip the nth zero, starting from the LSB, in a (Num b, Bits b) => b?
17:39 <nil_> Example: setNthZero 2 0 == 4
17:40 <nil_> (Not homework, incidentally.)
17:40 <benzrf> nil_: what's it for, though
17:41 <nil_> I'm porting a bunch of C++ snippets from a coding guideline to Haskell to see how different the algorithms come out. So a demonstrative exercise, basically.
17:42 <benzrf> nil_: are you worried about efficiency?
17:43 <nil_> benzrf: kind of. Not really, though. Elegance is the top priority.
17:44 <nil_> I'm tempted to use toListLE / fromListLe and then just look for the nth True.
17:44 <benzrf> im going even dumber, hold on
17:44 <benzrf> :]
17:45 hphuoc25 joined
17:47 <benzrf> nil_: ok, behold this overkill
17:47 <benzrf> @let setNthZero n = elementOf (bits . filtered not) n .~ True
17:47 <lambdabot> Defined.
17:48 <benzrf> > setNthZero 2 (0 :: Word8)
17:48 <lambdabot> 4
17:48 <nil_> :D Amazing. What does (.~) do?
17:48 <benzrf> this is a lens-based solution
17:48 <benzrf> well, i'm using traversals not lenses, but the lens package
17:48 <nil_> Ah, I'm not really familiar with lenses yet.
17:49 <benzrf> :>
17:50 <benzrf> jsyk this will hang forever if you try to use it with an infinite-precision type :^)
17:50 <nil_> Looks cool though. I'm going to put together something between my naive solution and this.
17:51 <benzrf> im pretty sure this is one of the worst ways you could do this
17:51 <nil_> :D
17:51 <benzrf> actually you know what i dont know if it is, maybe ghc is smart enough to optimize
17:51 <benzrf> let's find out...
17:51 <nil_> Are you going to run criterion on it?
17:52 <benzrf> hmm?
17:52 <benzrf> im going to compile it to c-- and see what comes out
17:52 <benzrf> i dont think ive ever actually done this before so i might not be able to read it :>
17:52 <Baikonur> I
17:54 pilne joined
17:54 <nil_> benzrf: criterion is the de facto standard benchmarking library fwiw.
17:55 <benzrf> kk
17:56 hoffmeyer joined
17:57 anmin joined
18:02 curious_corn joined
18:03 hoffmeyer joined
18:05 prophile joined
18:09 eacameron joined
18:14 <benzrf> ya ok lmao i cant fucking read c-- at all especially not STG c--
18:14 <benzrf> oh well
18:14 <benzrf> i am having a look at the optimized Core though
18:15 <benzrf> its marginally more readable
18:17 netheranthem joined
18:19 shadowPriest joined
18:24 <benzrf> hmm, what the fuck? why would this ever be true? is this a bounds check? https://i.imgur.com/6NnrRlJ.png
18:24 <benzrf> paging all Core experts ^
18:24 peterbecich joined
18:25 nepiktaz joined
18:26 eacameron joined
18:28 peterbec` joined
18:31 gabluc joined
18:31 <benzrf> oh :| ok this Core is starting to make sense...
18:31 gabluc_ joined
18:32 <nil_> What does it do?
18:33 <benzrf> looks like ghc was smart enough to compile away all of the lens stuff so that it's just basic-ass recursion and lists
18:33 <benzrf> but it IS still lists, not, like, checking indices
18:33 <benzrf> so there's the overhead of going word -> list -> word
18:34 <benzrf> i don't know if that gets optimized away at another stage, but i kind of suspect it doesn't
18:34 <nil_> I guess that was expected.
18:34 <benzrf> ;-;
18:34 <benzrf> whatever happend to fusion
18:36 kadoban joined
18:37 Glooomy joined
18:41 <benzrf> anyway it looks like it basically compiles down to something kinda like
18:43 <benzrf> er ok i dont wanna write this boring function
18:43 <benzrf> but basically it recurses, incrementing a) a counter of which digit we're on, b) how many zeros we've seen
18:44 <benzrf> generating a list of booleans of each digit, swapping out the boolean if the counters say we're at the right digit
18:44 <nil_> But it's still lists, you mean?
18:44 <benzrf> yup :(
18:44 <benzrf> im not sure if that's what's in the native code, but it's what's in the Core
18:44 <nil_> Whatever, it's good enough for me. :)
18:44 <benzrf> i'm kind of surprised there wasn't some kind of fusion here...
18:45 <benzrf> (this is the version with a specific type, fyi)
18:45 <benzrf> (i'm not bothering to read the core for the polymorphic version)
18:46 Gloomy joined
18:46 <benzrf> fwiw, laziness does mean that this is almost as good as a straightforward list-less version
18:46 <benzrf> ...i think
18:47 Gloomy joined
18:48 Gloomy joined
18:48 hphuoc25 joined
18:49 Gloomy joined
18:50 Gloomy joined
18:54 <benzrf> hmm
18:55 <benzrf> oh right, tagless... hmmmmmmmm
18:55 <benzrf> maybe that means it doesn't do any allocation :)
18:55 <benzrf> ok yeah, i think this actually does compile down to something pretty on par with an imperative-y version!
18:56 <benzrf> although... hmm... on the other hand, i think it traverses the entire word even if it hits the zero very early
18:56 <benzrf> that's definitely bad!
18:56 <benzrf> and i think it might be unavoidable in how lens traversals work
18:56 <benzrf> :[
18:57 <benzrf> ok, ive spent way too long on this silly thing
18:57 <benzrf> be back later.
18:57 <nil_> Here's what I got:
18:57 <nil_> https://gist.github.com/nilthehuman/85b221c0d45f3af6ffe2b42b7b974958
18:58 <nil_> (Obviously not an efficiency improvement, but a lot clearer.)
19:09 <qu1j0t3> HIRED
19:09 <nil_> qu1j0t3: congrats, I guess! Where?
19:10 <nil_> ...wait, was that a joke on benzrf's analysis rant?
19:11 <qu1j0t3> no, it was a ringing endorsement of clarity-bringers
19:18 permagreen joined
19:20 iamabeginner joined
19:20 shadowPriest joined
19:22 <iamabeginner> When using a list comprehension e.g. [x | x <- [0..10]], is there a way to get the index of x without referencing the list [0..10]?
19:22 <qu1j0t3> zipwithindex?
19:23 <nil_> iamabeginner: you could have the list comprehension give you pairs of values and indices, i.e. [(i,x) | i <- [0..], x <- [0..10]]
19:24 <iamabeginner> okay, I was hoping for something a little more elegant
19:24 <geekosaur> a list is not an array. it's a linked list; it has no indices
19:25 <iamabeginner> okay
19:25 <qu1j0t3> [x | x <- zip [0..] [0..10]]
19:25 <qu1j0t3> although of course if your original list is 0..10 this is a bit pointless :)
19:25 <iamabeginner> lol this was just for proof of concept
19:25 <nil_> qu1j0t3: ouch, you're right of course.
19:25 <qu1j0t3> > [x | x <- zip [99..] [0..10]]
19:25 <lambdabot> [(99,0),(100,1),(101,2),(102,3),(103,4),(104,5),(105,6),(106,7),(107,8),(108...
19:27 grayjoc joined
19:28 <qu1j0t3> and you can of course destructure the tuple with a pattern on the left of <-
19:28 <iamabeginner> I am trying to find an elegant way of selecting the kth element of a list using a list comprehension
19:29 <nil_> Is using a list comprehension a stated requirement?
19:30 <qu1j0t3> iamabeginner: add a filter here and you've got it
19:30 <iamabeginner> nil_ Not necessarily
19:31 tangled_z joined
19:31 <iamabeginner> qu1jot3: yes, I could add a filter with the zip, but I wonder if there is a better way
19:31 <qu1j0t3> > [b | (a,b) <- zip [0..] [100..105], a==2]
19:31 <lambdabot> [102]
19:33 <nil_> I reckon both vanilla recursion and using the library function (!!) are better ways of indexing into a list than a list comprehension though.
19:34 <qu1j0t3> yes, i'm only sticking to the list comprehension constraint :)
19:36 eacameron joined
19:41 peterbec` joined
19:43 aarvar joined
19:45 takle joined
19:46 curious_corn joined
19:50 <iamabeginner> is there a negative infinity integer?
19:51 <saylu> Hey folks! I'm learning about Arrows from John Hughes' original paper. He describes three operations for the Arrow class:
19:51 <saylu> arr :: (b -> c) -> a b c
19:52 <saylu> (>>>) :: a b c -> a c d -> a b d
19:52 <saylu> first :: a b c -> a (b, d) (c, d)
19:52 <saylu> My big struggle at the moment: Where does the `d` come from in `first`?
19:52 <nil_> iamabeginner: I don't think so. Integer is not Bounded, therefore there is no "least" Integer.
19:52 t0by joined
19:52 t0by joined
19:52 <saylu> I understand that first is meant to transform the first component of pairs (that's the b -> c in (b, _) (c, _))
19:53 <saylu> but where does the second component even come from? Type `d`?
19:53 <iamabeginner> nil_: okay, thanks
19:54 <nil_> saylu: first converts an Arrow between b and c to another Arrow between (b, d) and (c, d).
19:54 <nil_> That is, d may be literally anything the caller wants. Even undefined!
19:55 <nil_> > first (\x -> x*x) (5, undefined)
19:55 <lambdabot> (25,*Exception: Prelude.undefined
19:55 <saylu> Ok!
19:55 drewr joined
19:56 ego joined
19:58 <saylu> And functions are all arrows, right?
19:58 <saylu> so I can provide any function b -> c as the first arg
19:58 <glguy> To first?
19:58 <saylu> yes
19:58 <glguy> If you do that then you'll get a function back
19:58 <saylu> at least, any function a -> b is an arrow
19:59 <glguy> All functions are arrows, not all arrows are functions
20:00 <saylu> > :t first
20:00 <lambdabot> <hint>:1:1: error: parse error on input ‘:’
20:01 <geekosaur> :t first
20:01 <lambdabot> Arrow a => a b c -> a (b, d) (c, d)
20:01 <glguy> :t first . arr
20:01 <lambdabot> Arrow a => (b -> c) -> a (b, d) (c, d)
20:01 <saylu> > first (\x -> "hi") (2, "hello")
20:01 <lambdabot> ("hi","hello")
20:02 <saylu> Here, (2, "hello") is type a (b, d) (c, d)?
20:02 takle joined
20:02 <saylu> representing computation from (int, string) to (string, string)?
20:02 eacameron joined
20:02 <glguy> no, (2,"hello") has type (Integer,String) (defaulting to Integer)
20:02 <geekosaur> (2, "hello") is (b, d)
20:03 <geekosaur> and resolves as glguy said
20:03 <glguy> first in your example is using Bifunctor
20:03 <glguy> not Arrow
20:03 <saylu> Right, integer
20:03 <saylu> What, then, is 'a' exactly?
20:04 <glguy> saylu: a doesn't feature in your example
20:04 <glguy> err
20:04 <glguy> sorry, no
20:04 <glguy> :t first (\x -> "hi")
20:04 <lambdabot> (b, d) -> ([Char], d)
20:04 <glguy> a is (->)
20:04 <geekosaur> a is (->) here, isn't it?
20:04 <glguy> b is Integer
20:04 <glguy> d is String
20:04 <saylu> ah, OK
20:04 <saylu> right
20:05 <saylu> thanks!
20:05 <saylu> i'm finding arrows really tough to understand for some reason
20:05 <geekosaur> yes
20:05 <nil_> In the Arrow libraries 'a' conventionally stands for the Arrow instance being used.
20:05 <saylu> i appreciate the help glguy geekosaur
20:06 <* geekosaur> also still has trouble with Arrows, and the fact that a lot of the useful functions use tuples doesn't help; it throws the focus on the tuples instead of the arrow, IMO
20:07 <nil_> iamabeginner: apparently there's a module called "Data.Number.Transfinite" in a package that gives you infinities of different types.
20:08 <MarcelineVQ> try infix for clarity, first :: Arrow a => b `a` c -> (b, d) `a` (c, d)
20:08 eacameron joined
20:09 <nil_> MarcelineVQ: nice tip. You could even substitute a funky arrow symbol to make types more readable.
20:15 tangled_z joined
20:21 shadowPriest joined
20:29 <nil_> How would I refer to the multiplicative unit in a ring if I'm agnostic of /what/ ring I'm working in?
20:30 <nil_> I'm trying to write pow :: Num a => a -> Natural -> a
20:30 eacameron joined
20:31 hphuoc25 joined
20:31 chadrs joined
20:33 eacameron joined
20:41 chrissl joined
20:41 merijn joined
20:47 simendsjo joined
20:53 tangled_z joined
21:06 drewr joined
21:06 <monochrom> nil_: I think we just say "1" for all rings. Similarly, "0" for the additive identity.
21:09 <nil_> What if 'a' is not a single number?
21:09 <geekosaur> note that in Haskll, you usually do say 1 and let fromInteger sort it out
21:10 <saylu> Man, still struggling with my understanding here.
21:10 <saylu> > let funArr = arr (\x -> x + 5)
21:10 <lambdabot> <no location info>: error:
21:10 <lambdabot> not an expression: ‘let funArr = arr (\x -> x + 5)’
21:10 <saylu> hmm
21:10 <saylu> lpaste it is
21:11 <geekosaur> lambdabot is not ghci
21:11 <geekosaur> you can use @let
21:12 <saylu> http://lpaste.net/353922
21:12 <saylu> Ah, I see. I'll need to read up on lambdabot docs
21:13 <merijn> saylu: What's the problem?
21:14 azahi joined
21:14 <saylu> Sorry, I've updated it with a little explanation
21:14 <saylu> Basically, I'm trying to understand how the composition produces the type
21:15 <saylu> `cat (t1, t) (t, t1)`
21:15 <saylu> instead of, say
21:15 <saylu> `cat a (t, t1)`
21:15 <merijn> Well, if we look at >>> the 2nd type of the left hand needs to match the first of the right, yes?
21:15 <merijn> Since we have "(Arrow a, Num c) => a c c" on the left
21:15 <merijn> and "Arrow a => a (t1, t) (t, t1)"
21:15 <merijn> on the right
21:16 <merijn> we can conclude 'c = (t1, t)'
21:16 <merijn> And since left is 'a c c' it ends up being 'a (t1, t) (t1, t)' on the left
21:16 <merijn> And since 'c' must be a Num instance we get 'Num (t1, t)'
21:16 <saylu> Oof, that's right.
21:18 t0by joined
21:21 shadowPriest joined
21:22 splanch joined
21:23 <saylu> merijn: Does this look correct? Following through each operation of `second`?
21:23 <saylu> http://lpaste.net/353922
21:31 <nil_> saylu: I think you're mixing type level and function/value level expressions a bit?
21:31 eacameron joined
21:31 hphuoc25 joined
21:34 <saylu> totally possible
21:34 eacameron joined
21:35 <merijn> saylu: I looked at it a bit, but I've had sufficient beer that I got lost after a few lines :p
21:35 <saylu> I'm sure i've put an absolute mess here
21:35 <saylu> haha
21:35 <saylu> sorry about that
21:36 <nil_> saylu, have you tried feeding your code into ghci line by line?
21:36 <nil_> Scratch that, try :loading it instead!
21:37 <saylu> I'm going to take a break for a little while, come back, and I'll do it that way.
21:37 <saylu> Thanks!
21:41 eacameron joined
21:42 peterbec` joined
21:46 eacameron joined
21:49 eacameron joined
21:53 hiratara joined
22:00 eacameron joined
22:02 NoCreativity joined
22:05 splanch joined
22:13 eacameron joined
22:17 splanch joined
22:20 splanch_ joined
22:22 shadowPriest joined
22:24 splanch joined
22:30 <lpaste_> parsnip pasted “almost-json parser” at http://lpaste.net/353929
22:31 <parsnip> does my function naming look okay in this crowded parser?
22:31 hiratara joined
22:47 fred-fri joined
22:47 <fred-fri> would much appreciate any advice on how this can be improved https://gist.github.com/androidfred/26296cb7d2ef624ed2500f64eea62cdb
22:52 HaskellLord69 joined
22:52 Gloomy joined
23:03 <lpaste_> nil_ revised “arrows”: “arrows” at http://lpaste.net/353922
23:04 <nil_> saylu: I made some changes to your paste, I hope I didn't mess it up. Let me know if any of it helped.
23:15 curious_corn joined
23:17 systemfault joined
23:23 shadowPriest joined
23:34 splanch joined
23:36 eacameron joined
23:44 peterbec` joined
23:44 peterbecich joined
23:44 contiver joined