00:00:03 <elliott> well dependents kinda irrelevnat there
00:00:06 <Bike> nooodl: there are better ones but i'm not going to bother
00:00:08 <tswett> So in addition to having combinators representing functions, we'll also have to have combinators representing types.
00:00:17 <nooodl> http://nl.wikipedia.org/wiki/Lisp_(Lier) lispcon 2013 location
00:00:18 <elliott> Bike: you know lisp-N+1s are shit
00:00:46 <elliott> shitty mathematicians definition of the naturals
00:00:57 <elliott> isnt it amazing how there are mathematicians who ACTUALLY BELIEVE THE NATURALS START WITH ONE
00:01:03 <elliott> probably they don't even KNOW who PEANO is??
00:01:06 <Bike> Important issues, here.
00:01:12 <tswett> Phantom_Hoover: well, there's a finite state machine operating on a pointed directed unknot diagram.
00:01:19 <Sgeo_> Can't you have Z be 1?
00:01:28 <Sgeo_> erm, as in, starting point of Peanos
00:01:59 <Phantom_Hoover> i mean for fuck's sake what sort of addition doesn't even have an additive identity
00:02:30 <Sgeo_> nooodl, how's the Trustfuck impl going?
00:02:31 <elliott> Phantom_Hoover: i see your radical tendencies peeking out :-)
00:02:36 <elliott> Phantom_Hoover: how have you been feeling about the real nubmers lately
00:02:40 <tswett> Phantom_Hoover: the finite state machine is capable of moving the point around the diagram (but only forwards and backwards), as well as performing Reidemeister moves on the part of the diagram ahead of it.
00:02:47 <elliott> because almost all of them don't exist
00:02:54 <nooodl> i didn't know how much of my code was still correct
00:03:00 <monqy> is Phantom_Hoover a finitist
00:03:05 <nooodl> but i also didn't feel like rewriting a new impl from scratch juuust yet
00:03:10 <nooodl> maybe i'll make a new one later though
00:03:12 <elliott> MONQY constructivism isnt finitism
00:03:13 <Phantom_Hoover> elliott, hey half the reasons i maintain 0 \in N are normal maths
00:03:17 <Sgeo_> Help design Trustfuck 2?
00:03:43 <Bike> so anyway nother silly haskell question, how's show-ing of things that have only a quantified type work? like 17 since i fucked saying things
00:03:44 * Sgeo_ hides Smalltalk and Lua from Phantom_Hoover
00:03:46 <elliott> Phantom_Hoover: keep trying to convince urself chaitins constant existing is `normal'
00:03:52 <nooodl> does monqy believe 0 isn't \in N
00:03:54 <monqy> there are perfectly fine ways to "construct" the "reals"
00:04:05 <monqy> nooodl: 0 \in N for reasonable values of N
00:04:05 <nooodl> that's my latex ineuqality sign
00:04:12 <elliott> monqy: the computable reals are countable tho
00:04:12 <tswett> Bike: I think Haskell picks a default instance.
00:04:13 <monqy> nooodl: if you're talking to shit mathematicians though you have to be careful
00:04:17 <tswett> Which I think is Integer in this case.
00:04:18 <elliott> and all you can `construct' in eg coq
00:04:25 <Bike> tswett: Really? Boring.
00:04:45 <Phantom_Hoover> istr my foundations course was absolutely terrible with 0
00:04:49 <elliott> (but eg you have the thing where you can't write non-continuous functions w/o LEM)
00:04:59 <nooodl> hm. what's an example of a noncomputable real
00:05:02 <elliott> (b/c you cant case analysis on the reals)
00:05:05 <Bike> nooodl: chaitin's
00:05:05 <oerjan> <elliott> probably they don't even KNOW who PEANO is?? <-- the joke is that Peano started with 1, right?
00:05:25 <Bike> Phantom_Hoover: that's pretty usual, sometimes they use Ñ and stuff and it's hilariously dumb
00:05:51 <Bike> what's wrong with chaitin :(
00:05:55 <Bike> i mean besides that he's crazy but
00:06:00 <elliott> Phantom_Hoover: um chaitins is th ebest example
00:06:02 <Sgeo_> Here's an example: A real which cannot be described even with an infinite amount of symbols.
00:06:05 <tswett> Set a = 0 and b = 1, and then let R be a sequence containing all computable real numbers.
00:06:11 <nooodl> chaitin's looks like a good example. i expected something halting problem-y
00:06:17 <elliott> theres a bijection between reals and potentially infinite streams of bits
00:06:40 <tswett> Pop values x from R until a < x < b, then set a := x. Pop values y from R until a < y < b, then set b := y. Repeat forever.
00:07:00 <Sgeo_> Correct example: A real which cannot be described with any finite amount of symbols
00:07:01 <tswett> Both a and b will approach the same uncomputable number.
00:07:12 <Bike> Sgeo_: That's undefinable, not uncomputable.
00:07:29 <Sgeo_> If it's undefinable, it's uncomputable
00:07:37 <Bike> Yes, but not the converse.
00:07:50 <tswett> "Undefinable" has the unfortunate property of being undefinable.
00:08:04 <Phantom_Hoover> nooodl, also there are functions which grow faster than any computable function
00:08:05 <nooodl> i thought making a sequence of all real numbers was impossible! computable or not
00:08:23 <Bike> if by "a sequence" you mean "a bijection with the naturals" then yes
00:08:29 <Phantom_Hoover> the computable reals are a subset of turing machines, or whatever other tc system you want
00:08:43 <tswett> nooodl: there is indeed no sequence that contains all real numbers. However, there is a sequence that contains all computable real numbers.
00:08:51 <Phantom_Hoover> so you can count them, plus a bunch of TMs which aren't computable reals
00:09:08 <Phantom_Hoover> but you can't actually tell if a given element is a CR without the halting problem
00:09:39 <oerjan> Bike: haskell has a default declaration which is used to pick default instances for things, the default default is default (Integer, Double) hth. also ghc has an extension to make it apply in more cases, and also prepends () to the default types.
00:09:58 <Bike> wait that actually does help? what the fuck what is this
00:10:07 -!- sebbu has joined.
00:10:10 <tswett> (a, b, c) really ought to be syntactic sugar for (a, (b, c)).
00:10:24 <elliott> nooodl: you can well-order the rael numbers :-)
00:10:25 -!- sebbu has quit (Changing host).
00:10:25 -!- sebbu has joined.
00:10:42 <Sgeo_> tswett, tell that to elliott, who disagrees
00:11:10 <elliott> yes make me into the absolute hub for not thinking that specific kind of hlist desugaring is a bad idea
00:11:16 <nooodl> "the computable reals are a subset of turing machines" hmmm
00:11:43 <tswett> nooodl: how about this: "the set of all Turing machines that output real numbers is a subset of the set of all Turing machines."
00:11:57 <Phantom_Hoover> nooodl, a cr is basically a TM implementing a function N -> Q that converges
00:12:14 <tswett> And given a Turing machine that outputs a real number, there is an obvious real number corresponding to it.
00:13:23 <tswett> All right. So my language, as I'm currently imagining it, currently only has "if" statements for flow control.
00:13:28 <nooodl> yikes now i'm thinking about things
00:13:32 <elliott> 00:08:05 <nooodl> i thought making a sequence of all real numbers was impossible! computable or not
00:13:40 <elliott> note that the computable reals are a subset of the reals like the naturals are a subset of the reals
00:13:45 <elliott> and i'm sure you believe you can make a sequence of rationals
00:13:50 <elliott> (the set of computable reals is countable)
00:13:59 <Lumpio-> I can make a sequence of all real numbers that are either two or pi
00:14:23 <tswett> 2, pi, pi, 2, pi, 2, 2, pi, pi, 2, 2, pi, 2, pi, pi, 2, pi, 2, 2, pi, 2, pi, pi, 2, 2, pi, pi, 2, pi, 2, 2, pi, ...
00:15:18 <tswett> Let's condense that sequence. It alternates between 2 and pi, using each one the following number of times: 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, ...
00:15:22 <Lumpio-> No actually it's just 2 and pi, repeating is silly
00:15:42 <tswett> Which, in turn, alternates between 1 and 2, using each one the following number of times: 1, 1, 2, 3, 2, 1, 2, 1, 2, 3, 2, 1, ...
00:15:46 <oerjan> <elliott> nooodl: you can well-order the rael numbers :-) <-- unidentified well-founded ordering
00:16:10 <elliott> oerjan: yes. but only with extensional choice
00:16:10 <tswett> Which, if you ignore the beginning 1 and drop all the 2s (since every other number, apart from the beginning 1, is a 2), you get this: 1, 3, 1, 1, 3, 1, ...
00:16:14 <nooodl> "[...] implementing a function N -> Q that converges" i still don't see how that represents a computable real :(
00:16:21 <elliott> (i.e., the choice that is a theorem (not axiom) of type theory does not give it)
00:16:27 <Sgeo_> o.O at parsers parsing things other than strings
00:16:39 <elliott> (and extensional choice implies LEM, iirc)
00:16:39 <nooodl> the real value is just f(0) + f(1) + f(2) + ...?
00:17:16 <Phantom_Hoover> the upshot is, almost all the reals are impossible to define in any meaningful way
00:17:17 <tswett> And that, in turn, alternates between 1 and 3, using each one the following number of times: 1, 1, 2, 1, ...
00:17:37 <Phantom_Hoover> and indeed this is true even if you're being nonconstructive
00:18:01 <oerjan> <elliott> oerjan: yes. but only with extensional choice <-- you missed the pun on your misspelling hth
00:18:13 <tswett> All right. So my language, as I'm currently imagining it, currently only has "if" statements for flow control. This makes the language definitely not Turing-complete; you can, in O(n) time, look at a program and place an upper bound on the length of time for which it will run.
00:18:34 <tswett> Assuming you can perform arithmetic in O(1) time.
00:19:01 <lambdabot> It could refer to either `Control.Arrow.<+>',
00:19:01 <lambdabot> imported from `Control.Arrow' at State/L.hs:5:1-20
00:19:04 <elliott> oerjan: oh that was rly stupid
00:19:38 <tswett> So I need some way to go back and loop.
00:20:08 <oerjan> tswett: btw why didn't you use the kolakoski sequence above hth
00:20:29 <Phantom_Hoover> tswett, why did you have to say all the stuff about it while like 2 other discussions were going on
00:20:51 <tswett> Phantom_Hoover: nobody told me not to.
00:22:07 <oerjan> ^ul (12)S(*a(~:)~*^~):((1)S)~*~((2)S:*)~*:(~:()~)~*^(a(:^)*~a(*()~)~*^~^):^
00:22:09 <fungot> 122112122122112112212112122112112122122112122121121122122112122122112112122121122122112122122112112212112122122112112122112112212112112212211212212112212212112112212211212212112112212112122112112122121122122112122122112112122112112212212112122112112212112112212212112122112112122122112122121121122122121122122112122122112112 ...too much output!
00:25:25 <nooodl> > let kola = [1] ++ concat $ zipWith replicate kola $ cycle [2,1] in take 20 kola
00:25:27 <lambdabot> Couldn't match expected type `[t0]'
00:25:36 <nooodl> > let kola = [1] ++ (concat $ zipWith replicate kola $ cycle [2,1]) in take 20 kola
00:25:38 <lambdabot> [1,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2]
00:25:54 <oerjan> nooodl: you don't need to use take in lambdabot
00:26:03 <nooodl> boo. it gets the start wrong somehow
00:26:11 <tswett> nooodl: you're not removing the initial 1.
00:26:22 <Bike> i "realized" while out that it might be more interesting that constructivists would deny the existence of say the set of subsets of the naturals rather than reals but this is probably because i don't yet truly know how fucked up computable analysis is
00:26:30 <tswett> > let kola = [1,2] ++ (concat $ zipWith replicate (drop 2 kola) $ cycle [2,1]) in take 20 kola
00:26:42 <tswett> Maybe that's not the problem.
00:26:48 <elliott> Bike: have you noticed that powersets are scary
00:27:00 <Bike> well they only drove cantor insane
00:27:28 * Bike was thinking about the set of all subsets of a set not containing an element of the set earlier, and it got tied up with this
00:27:40 <Bike> i read a paper once on "power types"
00:27:41 <nooodl> > let kola@(_:ks) = [1] ++ (concat $ zipWith replicate kola $ cycle [2,1]) in 1:2:ks
00:27:43 <lambdabot> [1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,1,2,2,1,...
00:27:46 <Bike> now that was some good shit
00:29:10 <Phantom_Hoover> * Bike was thinking about the set of all subsets of a set not containing an element of the set earlier, and it got tied up with this
00:29:40 <tswett> Oh. Not containing a *given* element of the set.
00:29:43 <nooodl> oh huh kolakoski is A000002
00:29:47 <tswett> As opposed to not containing *any* element of the set.
00:29:58 <Bike> wouldn't that just be empty
00:30:07 <tswett> It's like A000001, except posterior.
00:30:11 <tswett> Bike: it would be {{}}, yeah.
00:30:17 <oerjan> > fix(([1,2]++).drop 2.concat.zipWith(flip replicate)(cycle[1,2]))
00:30:19 <lambdabot> [1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,1,2,2,1,...
00:31:15 <tswett> Trivia: "sword" is not a subword of "subword".
00:31:26 <Sgeo_> Do people use Parsec when making stuff for QQ stuff in Haskell?
00:31:47 <monqy> Q: why are you doing QQ stuff
00:32:02 <monqy> just making sure you're not hopped up on macros again
00:32:28 <Sgeo_> Yesod uses it, right?
00:32:39 <nooodl> ugh. Q: how do math people write that a function returns, for example, a set of reals
00:33:11 <monqy> i think ive also seen subset
00:33:29 <monqy> powerset is what i see most of the time
00:34:05 <nooodl> wow crazy people use ℙ for powerset according to wikipedia
00:34:33 <Bike> solely to piss off kmc no doubt
00:35:08 <monqy> dont use blackbord bold for powerset....
00:35:08 <nooodl> ℙ(ℙ) "power set of prime set"
00:35:40 <nooodl> math's notation is such a fucking trainwreck at times
00:35:41 <monqy> i think mathcal is the proper font to use? i'm fairly certain i've seen mathsf and mathscr though
00:36:20 <Phantom_Hoover> fortunately there's not much confusion with the latter because the weirstrass function is never actually used as a function
00:36:45 <monqy> nooodl: at times/most of the time really
00:37:08 <nooodl> well sometimes it's really good & clever
00:37:13 <tswett> What does the "sf" in mathsf stand for?
00:37:27 <Phantom_Hoover> nooodl, it helps if you remember that it's still mostly written by hand
00:37:30 <Bike> nooodl: like....
00:37:49 <Sgeo_> "This combinator is provided for compatibility with Parsec. Attoparsec parsers always backtrack on failure."
00:38:01 <Bike> have you ever looked at a 9
00:38:05 <Phantom_Hoover> and there are a load of ways to write any given symbols
00:38:05 <Bike> like really looked at a 9
00:38:22 <monqy> 9 is pretty heck but i love 7 so it makes up for it
00:38:22 <tswett> Like, an actual 9, or a numeral 9?
00:38:43 <nooodl> surely someone out there has had the zany idea to reinvent the notation for Everything
00:38:44 <elliott> except you have to dash the 7
00:38:49 <elliott> and then it looks not so good
00:38:52 <monqy> i always dash my 7s
00:38:52 <Phantom_Hoover> because those times when you nail it and it has an elegant curl in the tail are the best things ever
00:38:55 <monqy> i love dashes on 7s
00:38:57 <elliott> i hate 1 because you need to make it all fancy to avoid ambiguity
00:39:00 <Bike> nooodl: you have no idea
00:39:01 <monqy> i also give my 7s cute little hooks
00:39:05 <elliott> and its also the caues of the 7 Ambiguity Problem
00:39:16 <monqy> sometimes my 7s look like my ts, or maybe it's more that my ts look like my 7s
00:39:20 <Bike> also i wrote out a 4 the other day and one of my coworkers stopped me for two minutes to ask me about how i wrote it
00:39:25 <Bike> "i've never seen someone write a 4 like that"
00:39:26 <elliott> monqy: whats your handwriting look like
00:39:26 <nooodl> jesus. i write my 2s like a normal person and it makes them look a lot like Zs or zs
00:39:41 <elliott> i like how the variable x looks but im so bad at writing it
00:39:53 <Bike> x is christian propaganda
00:40:05 <nooodl> my x is literally an x
00:40:24 <elliott> you're disgusting, rectify yourself
00:40:41 <Phantom_Hoover> but once you get the hang of it the / runs together and it looks great
00:41:19 <nooodl> this is the only picture of my math handwriting i've got https://dl.dropbox.com/u/15495351/snow/IMAG0043.jpg
00:41:38 <nooodl> which is probably 1 more picture than the average person
00:42:06 <shachaf> elliott already knows what my "math handwriting" looks like
00:42:22 <monqy> elliott: i have a few copeies of me trying to handwrite on my tablet from a while ago...there's an aspect ratio problem which messes up my hand-eye coordination so it's kind of eugh
00:42:37 <Bike> dumb question again, how do i write "numLongChains long max = length $ longChains long max" in that fancyass pointless style
00:42:42 <nooodl> i have this thing too which is normal writing and it's very real
00:42:45 <nooodl> https://dl.dropbox.com/u/15495351/snow/IMAG0046.jpg
00:43:07 <Sgeo_> Bike, you can ask lambdabot
00:43:08 -!- Nisstyre-laptop has joined.
00:43:17 <tswett> @pl numLongChains long max = length $ longChains long max
00:43:17 <Bike> nvm figured it out
00:43:17 <lambdabot> numLongChains = (length .) . longChains
00:43:19 <nooodl> Bike: numLongChains = length .: longChains
00:43:25 <Phantom_Hoover> note how nooodl double-spaces his work and sets it all out neatly
00:43:37 <monqy> i use latex for math
00:43:45 <monqy> writing is for losers
00:43:59 <nooodl> monqy: i can't do that at school!!!
00:44:17 <Bike> wait is this linguistics
00:44:21 <monqy> elliott: gosh i have 6 pictures of me trying to handwrite and they're all sorta different
00:44:35 <monqy> elliott: i forget what i did differently each time except for handwriting6.png
00:44:37 <shachaf> i want to see monqys trying to handwrite
00:44:43 <Phantom_Hoover> i want to use latex but why does it have to have all that madness with \doctype and headings and everything
00:44:52 <shachaf> btw i have worse handwriting than any of you
00:44:59 <nooodl> latex is literally the worst thing
00:45:13 <monqy> https://dl.dropbox.com/u/13786158/handwriting.png
00:45:14 <monqy> https://dl.dropbox.com/u/13786158/handwriting2.png
00:45:15 <monqy> https://dl.dropbox.com/u/13786158/handwriting23.png
00:45:16 <elliott> dont tell people to use (.:)
00:45:19 <monqy> https://dl.dropbox.com/u/13786158/handwriting3.png
00:45:21 <monqy> https://dl.dropbox.com/u/13786158/handwriting4.png
00:45:24 <monqy> https://dl.dropbox.com/u/13786158/handwriting5.png
00:45:26 <monqy> https://dl.dropbox.com/u/13786158/handwriting6.png
00:45:29 <monqy> there thats all of them
00:45:30 <nooodl> are you going to tell me to use (.).(.)
00:45:33 <nooodl> if so i'm going to cry
00:45:34 <monqy> (handwriting23 does not exist)
00:45:40 <elliott> im going to tell you to add a fuckn point
00:45:43 <monqy> dont use (.).(.)...............................
00:45:52 <Bike> what the heck is .:
00:45:53 -!- md_5 has quit (Ping timeout: 248 seconds).
00:46:02 <nooodl> holy shit. monqy's handwriting
00:46:02 <elliott> monqy: shit your handwriting is nice
00:46:07 <lambdabot> Source not found. Do you think like you type?
00:46:20 <Sgeo_> Bike, it exists, but may be considered to be an excessive use of pointfree style
00:46:27 <elliott> well i dont like the unfilled dots
00:46:36 <shachaf> imo dijkstra has the best handwriting
00:46:40 <Bike> imo monqy should dot his js with a heart
00:46:41 <shachaf> so you might as well give up now
00:46:42 <monqy> when im writing with a real pen i think i use normal dots
00:46:48 <nooodl> here's a little "latex gem"
00:46:48 <Sgeo_> Although "exists" as in, "well-known", not "standard"
00:46:49 <nooodl> \chemname{\chemfig{C([2]-\lewis{024,Cl})([6]-\lewis{046,Cl})([:-150]-\lewis{357,Cl})([:-30]-\lewis{157,Cl})}}{Koolstoftetrachloride}
00:46:50 <monqy> but with tablets i cant resist
00:47:14 <shachaf> U+24A38 COMBINING HEART ABOVE
00:47:27 <Sgeo_> Oh hey Aeson uses .: for something else
00:47:40 <elliott> my hand writing is worse than nooodls by far tho
00:47:55 <Phantom_Hoover> that's for a diagram, however you represent that textually it's going to be awkward
00:48:20 <nooodl> i can write really neatly if i try
00:48:21 <elliott> like my handwriting is honestly a 6 year olds
00:48:31 <shachaf> elliott: my handwriting is a 3 years olds??
00:48:49 <elliott> shachaf: do you even have any proof all i see is you syaing your handwriting is so much worse than everyone else's!!
00:48:58 <shachaf> elliott: do you have proof!!
00:49:01 <nooodl> what now Phantom_Hoover!!!!!
00:49:25 <tswett> I can write in cursive, but only words that only contain the letters a, e, h, i, n, o, s, and t.
00:49:40 <tswett> There are a bunch of such words.
00:49:45 <Phantom_Hoover> nooodl, good luck writing a transparent parser for that
00:50:08 <tswett> I have a little sheet of paper on which I've written "anaesthesia antiatheist assassination ensheathe hastiness heathenishness hesitation honestness ..."
00:50:15 <tswett> Sgeo_: you know, I think any function can be thought of as a parser.
00:50:18 <nooodl> "you don't need to parse pure beauty any further"
00:50:18 <monqy> im going to try handwriting again
00:50:29 <Phantom_Hoover> the entire point of latex is that you give it a general representation and leave the typesetting details to it
00:50:45 <elliott> i think dijkstras handwriting is still a bit better than monqys
00:50:45 <Sgeo_> PArrows is unmaintained :(
00:50:57 <monqy> my handwriting is smaller than that irl
00:51:00 <elliott> Phantom_Hoover: fsvo all of that
00:51:03 -!- md_5 has joined.
00:51:04 <monqy> but my tablet setup is miserable
00:51:09 <monqy> and i dont have a scanner or anything
00:51:10 <Jafet> Help what is handwriting
00:51:19 <elliott> monqy: by smaller i mean... less fussy mainly??? as in less ... "area"
00:51:22 <nooodl> i stole my f's from dijkstra
00:51:24 <lambdabot> lexical error in string/character literal at end of input
00:51:25 <elliott> i dont know how to express the meaning
00:51:30 <nooodl> but they don't look like dijkstra f's anymore...
00:51:33 <monqy> yeah my handwriting is pretty fussy
00:51:48 <nooodl> is there a good nooodl f in that image
00:51:48 <lambdabot> unexpected end-of-file in string/character literal at end ...
00:52:22 <nooodl> yeah https://dl.dropbox.com/u/15495351/snow/IMAG0046.jpg there's "koffie" near the bottom right corner
00:52:41 <shachaf> elliott: if you come to america ill show you my handwriting
00:52:43 <elliott> nooodl: all these words are spelled wrong
00:52:51 <elliott> and they don't mean anything?
00:52:59 <elliott> you must get awful grades in english
00:53:07 <nooodl> whats your favorite word on this page elliott
00:53:28 <elliott> or maybe the one that looks like "groudshroffen"
00:53:46 <nooodl> "grondstoffen", "kolonie"
00:54:06 <elliott> ziet seems like the kind of word that always wants to have a ! after it
00:54:10 <nooodl> that's "suiker" (sugar)
00:54:31 <nooodl> elliott: that's actually some kind of old-fashioned imperative
00:54:52 <nooodl> "aanstelling" i don't even know how to translate that
00:55:14 <tswett> That's not a "t", though, that's an "h".
00:55:39 <nooodl> that's just because i'm bad at writing letters :(
00:56:22 <nooodl> i can see what happened, though. wanted to write a 't', and then i had to lower my pen a bit to start writing the 'e', but i didn't lift it from the paper, whoops
00:57:06 <elliott> ziettttttttttttttttttttttttttt!!!!
00:57:39 <oerjan> > fix(concat.(zipWith.flip.sequence$sequence[const pure,(tail.).replicate])(cycle[1,2]))
00:57:40 <lambdabot> Couldn't match expected type `a0 -> c0' with actual type `[a1]'
00:57:50 <Bike> i wrote "longChains long max = filter ((> long) . length) (map chain [1..max])". is my "style" an insult to all that is holy or
00:57:50 <oerjan> no way that would work on first try
00:57:51 <elliott> monqy: i just thought of a really awful pun
00:57:51 <nooodl> aanstelling is "appointment, commission, nomination"
00:58:11 <nooodl> can i; did i inspire it
00:58:15 <oerjan> :t sequence$sequence[const pure,(tail.).replicate]
00:58:17 <lambdabot> Couldn't match expected type `[a0]' with actual type `b0 -> a1'
00:58:17 <lambdabot> In the return type of a call of `const'
00:58:17 <lambdabot> Probable cause: `const' is applied to too few arguments
00:58:32 <oerjan> :t sequence$sequence[const pure]
00:58:33 <lambdabot> Couldn't match expected type `[a0]' with actual type `b0 -> a1'
00:58:33 <lambdabot> In the return type of a call of `const'
00:58:33 <lambdabot> Probable cause: `const' is applied to too few arguments
00:58:36 <nooodl> ooh http://nl.wiktionary.org/wiki/ziet this page actually has "Ziet!" on it
00:59:05 <oerjan> :t sequence$sequence[]
00:59:21 <elliott> nooodl: you probably want en.wiktionary
00:59:26 <elliott> foo.wiktionary.org means entries are in language foo
00:59:29 <elliott> they all cover all languages
00:59:38 <elliott> tho en.wiktionary's ziet doesn't have ziet!
00:59:46 <elliott> q: what did the great film written by a mathematician have?
00:59:52 <nooodl> en.wiktionary.org covers less dutch stuff :(
01:00:01 <Bike> @hoogle (Functor f) => (a -> b -> a) -> a -> f b -> a
01:00:02 <lambdabot> Data.Foldable foldl :: Foldable t => (a -> b -> a) -> a -> t b -> a
01:00:02 <lambdabot> Data.Foldable foldl' :: Foldable t => (a -> b -> a) -> a -> t b -> a
01:00:03 <lambdabot> Data.IntMap foldl :: (a -> b -> a) -> a -> IntMap b -> a
01:00:12 <nooodl> i'm smiling pretty hard at elliott's pun
01:01:01 <elliott> Bike: how would "that work" exactly
01:01:37 <nooodl> how would ""what work""
01:01:39 <Bike> guess it wouldn't
01:01:50 <Bike> folds over functors
01:02:21 <elliott> well did you mean Foldable
01:02:29 <elliott> Functor only provides (a -> b) -> f a -> f b
01:02:33 <elliott> so i'm not sure what your operation is meant to do
01:02:45 <Bike> it is meant to go "huh [] is a functor isn't it!!" because
01:03:51 <monqy> https://dl.dropbox.com/u/13786158/handwriting-hell.png i tried a few takes
01:04:09 <nooodl> monqy's handwriting is graffiti
01:04:46 <monqy> if i'm trying to make it particularly legible it gets boring
01:05:02 <nooodl> that's the handwriting dilemma!
01:05:55 <Bike> hm, i have to specify Prelude.foldl or Data.Foldable.foldl even if i'm just folding a list so it's the same
01:06:37 <oerjan> > fix(concat.zipWith(\x n -> x:replicate(n-1)x)(cycle[1,2]))
01:06:44 <oerjan> > fix(concat.zipWith(\x n -> x:replicate(n-1)x)(cycle[1,2]))
01:07:09 <oerjan> possibly something is wrong here
01:07:14 <Bike> where's fix again, i want fix
01:07:23 <lambdabot> Control.Monad.Fix module Control.Monad.Fix
01:07:23 <lambdabot> Data.Function fix :: (a -> a) -> a
01:09:30 <elliott> <Bike> hm, i have to specify Prelude.foldl or Data.Foldable.foldl even if i'm just folding a list so it's the same
01:09:39 <elliott> you're meant to import Foldable qualified, or hide the functions from Prelude
01:09:58 <Bike> i'm sure, i was just wondering if it would subsume the prelude definition
01:10:11 <elliott> monqy: your handwriting got smudgier
01:10:14 <elliott> did you leave it out in the rain
01:10:41 <monqy> elliott: gimp update =/
01:10:50 <tswett> That type II Reidemeister move thing is going to be difficult to realize.
01:10:53 <monqy> it got a new pen tool interface
01:11:13 <monqy> or do you mean the shapes of the letters
01:11:16 <monqy> it might have gotten smudgier
01:11:39 <monqy> oh yeah that's gimp
01:11:53 -!- augur has joined.
01:25:17 <oerjan> you don't need the first .*
01:25:57 <HackEgo> 2009-10-11.txt:06:42:55: * ehird erects anti-swatting forcefield around himself
01:26:32 <HackEgo> http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.5952
01:26:36 * oerjan gives elliott a very delayed swat -----###
01:27:47 <oerjan> wait, maybe it is not right to punish elliott for that terrible 2009 person
01:27:47 <hagb4rd> actually i'm looking for the cats with the heart shaped eyes^^
01:28:01 <oerjan> nooodl: not to my knowledge.
01:29:18 <hagb4rd> punishing cannot be elliott
01:29:28 <hagb4rd> punishing elliott cannot be wrong
01:29:32 <Bike> "impomatic, why would the switch to the forcefield be inside the asylum?" good lo
01:29:46 <Bike> "<Bike> ⌇⌇forcefields⌇⌇" definitely a good log
01:30:08 <oerjan> _someone_ hasn't set up their charset properly.
01:31:02 <hagb4rd> http://esolangs.org/wiki/CAT
01:31:11 <Phantom_Hoover> it's just an object in the something of small somethings
01:32:22 <HackEgo> Monoids are just categories with a single object.
01:32:39 <HackEgo> Categories are just a special case of bicategories.
01:32:53 <HackEgo> An object is just something in a category.
01:34:18 -!- madbr has joined.
01:37:26 <hagb4rd> ^ord ⌇⌇forcefields⌇⌇
01:37:26 <fungot> 195 162 197 146 226 128 161 195 162 197 146 226 128 161 102 111 114 99 101 102 105 101 108 100 115 195 162 197 146 226 128 161 195 162 197 146 226 128 161
01:39:58 <hagb4rd> how can do boolean bitwise comparison on two integers in haskell ..bytes for example
01:41:11 <fungot> 40 66 32 38 38 32 65 41
01:41:50 <fungot> 40 34 66 34 124 34 65 34 41
01:42:28 <lambdabot> No instance for (GHC.Num.Num GHC.Types.Bool)
01:44:22 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
01:44:49 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
01:44:55 <fungot> +++++++++++++++[>++++++++>++++>+++++++>+++++++<<<<-]>>++++++.>++++++.<<----.>----------------------------------.<----.>>+++.<<-----------.+.>>>.<++++++.<<-.>>-----.<++++++++++++++++++++++++++.--------------------------.<+.>>++.>+++++.<<<+.>>>+.<-.<.>----------------------.<++++++++++++.------------.>----------------------.<<------.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>>----.<---.<++++.++++++++.>-
01:45:57 <fungot> >,[>,]<[<]>[<++++[>--------<-]+>-[-------[--[<+++[>----<-]+>[<
01:49:02 <fungot> +15[>+8>+4>+7>+7<4-]>2+6.>+6.<2-4.>-34.<-4.>2+3.<2-11.+.>3.<+6.<2-.>2-5.<+26.-26.<+.>2+2.>+5.<3+.>3+.<-.<.>-22.<+12.-12.>-22.<2-6.>+67.>2-4.<-3.<+4.+8.>-37.<2-.>2+12.-12.<2-27.>3-4.<2.<-3.>.+5.>.+.+11.-12.>+5.-11.+12.-11.+2.-3.+.+13.<2.>.<2-2.>2.>.<2-2.>.>-48.-19.<.<+2.<+40.>+.-.+.<-6.+13.>-.>.>-.+.<.<2-2.-8.>.<-4.>-.<+4.+11.>-10.-8.>.<2+14.>3.<.<+9.>+67.<+5.-..>2-12.+9.+3.-12.<-.<-2.<-11.-2.>2.+13.<2+3.>3.+.
01:49:30 <oerjan> str:0 contains the code for prefixes
01:50:57 <oerjan> it is possible the str:n syntax only works in ^def, not plain ^bf
01:51:24 <lambdabot> Prelude (&&) :: Bool -> Bool -> Bool
01:51:24 <lambdabot> Data.Bool (&&) :: Bool -> Bool -> Bool
01:51:24 <lambdabot> Control.Arrow (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
01:51:34 <Bike> huh, why no & anywhere?
01:51:44 <oerjan> it's in Data.Lens now :)
01:52:02 <oerjan> it's just flip ($), anyway
01:52:29 <Bike> i just meant the identifier. i would have expected & instead of .&., that sort of thing
01:52:46 <oerjan> i don't know why no one used it before
01:53:07 <oerjan> it's probably because they couldn't use | as that's syntax
01:53:18 <oerjan> so they made it .&. by analogy with .|.
01:53:42 <hagb4rd> would be familiar at least
01:54:06 <Bike> hagb4rd: those are the booleans.
01:54:12 <Bike> haskell is basically just glorified C right
01:54:36 -!- nooodl has quit (Ping timeout: 272 seconds).
01:54:36 <lambdabot> Functor f => f a -> (a -> b) -> f b
01:54:53 <lambdabot> The operator `Control.Lens.Combinators.<&>' [infixl 1] of a section
01:55:04 <lambdabot> Not in scope: data constructor `A'
01:55:04 <Bike> > 64 `shiftL` 1
01:55:11 <Bike> have you considered: documentation
01:55:57 <Bike> behold http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/Data-Bits.html
01:55:59 <hagb4rd> i'm not really out for sth
01:56:39 <hagb4rd> maybe for some conversation
01:57:12 -!- carado has quit (Ping timeout: 256 seconds).
01:57:29 <hagb4rd> conversation is such a dirty word
01:58:31 <oerjan> stupid operator, does some silly vertical merging
01:58:47 <oerjan> unlike the intuitive $+$ version
01:59:27 <oerjan> > text "like" $$ nest 4 (text "this") -- maybe
01:59:39 <oerjan> > text "like" $$ nest 5 (text "this") -- maybe
01:59:51 <oerjan> seems it wants at least a space
01:59:56 <oerjan> > text "like" $+$ nest 5 (text "this") -- maybe
02:00:22 <oerjan> (lambdabot has an extra space on the first line)
02:03:16 -!- carado has joined.
02:08:26 <oerjan> i can understand that they might want $$ for haskell do blocks and the like, but not making it the default vertical combiner.
02:09:40 -!- carado has quit (Ping timeout: 256 seconds).
02:39:51 -!- copumpkin has quit (Ping timeout: 276 seconds).
02:40:22 -!- copumpkin has joined.
02:52:04 <oerjan> > length . filter (< 2^30) . take 1000 . randomRS (0,1431655765) $ mkStdGen 42
02:52:12 <oerjan> > length . filter (< 2^30) . take 1000 . randomRs (0,1431655765) $ mkStdGen 42
02:52:41 <oerjan> > 2^30/1431655766 * 1000
02:53:48 <oerjan> > length . filter (< 1431655765 `div` 2) . take 1000 . randomRs (0,1431655765) $ mkStdGen 42
02:55:08 <oerjan> > genRange (undefined :: StdGen)
02:56:02 <oerjan> > 2 * genRange (undefined :: StdGen) `div` 3
02:56:04 <lambdabot> No instance for (GHC.Real.Integral (GHC.Types.Int, GHC.Types.Int))
02:56:16 <oerjan> > 2 * snd (genRange (undefined :: StdGen)) `div` 3
02:58:44 <oerjan> > length . filter (< 1431655708 `div` 2) . take 1000 . randomRs (0,1431655708) $ mkStdGen 42
02:59:22 <oerjan> hm i thought the discrepancy would be the other way around...
03:06:07 <oerjan> it's pretty bad, anyway :P
03:07:17 <oerjan> (basically System.Random uses mod to generate random integrals.)
03:08:34 <elliott> System.Random is kind of awful
03:17:40 -!- hagb4rd has quit (Ping timeout: 250 seconds).
03:17:49 <zzo38> Just using mod is not good enough by itself though
03:18:15 <Bike> isn't that the point
03:18:17 <oerjan> no, it makes it potentially awful, as i demonstrated.
03:18:24 <zzo38> There are ways to improve it, though.
03:18:30 <oerjan> half the range is twice as likely as the other
03:18:53 <oerjan> although i don't understand why it's _that_ half and not the other :P
03:19:25 <zzo38> Yes, and I thought of that when programming TeXnicard, and other programs, too.
03:19:46 <zzo38> Notice that the Pokemon card named DIGGER also makes probabilities such as 2/3 with coins, is another way.
03:19:59 <zzo38> You also need good quality random number generators. Is ARCFOUR good enough?
03:20:41 <zzo38> Is ARCFOUR+delay+microphone good enough? (This is what Famicom Hangman uses)
03:20:46 <oerjan> i have no idea about that bit :P
03:20:50 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
03:21:10 <oerjan> i just had a look in System.Random's code, noticed the ominous `mod`, and wanted to test it
03:21:49 <oerjan> (i originally wanted to see how well it deals with unusual genRanges. the answer to that is: not at all.
03:22:20 <oerjan> it simply assumes genRange is the same as for stdGen.
03:22:32 <oerjan> and _still_ manages to do things badly for that.
03:23:49 <oerjan> presumably it's still ok as long as the range is tiny, and for floats.
03:34:51 <oerjan> http://hackage.haskell.org/trac/ghc/ticket/5280
03:44:28 -!- impomatic has quit (Quit: http://corewar.co.uk).
04:05:12 -!- Arc_Koen has quit (Quit: Arc_Koen).
04:31:06 <Sgeo_> Time to try to break my brain thinking about a language based off Trustfuck
04:31:13 <Sgeo_> Let's call it Trustfuck--
04:31:36 <Sgeo_> As though it were a prior version of Trustfuck.
04:32:26 <Sgeo_> All I'm going to say for now, while I go to make food and think
04:39:22 <monqy> dont just leave us hanging
04:43:17 <Sgeo_> Maybe ! should just do trustfuck primitives, rather than "current language" primitives, and a primitive be added for quines, and some other features to make converting ! to mean "current language" a relatively simple task
04:44:47 <Sgeo_> Although now I'm wondering if something vaguely inspired by Feather might be a good idea
04:45:01 <Sgeo_> Would ais523 be mad if I called a language "Featherfuck"?
04:45:37 <Bike> does the vague inspiration involve time travel? if not you're fine
04:47:26 <Sgeo_> Either reruning code or doing some fixed-point thingamabob
04:48:23 <Sgeo_> Haven't thought through the fixed-point thing well enough to know if it's even a coherent thought, although probably not
05:03:50 <Sgeo_> In disadvantages of ropes, the Wikipedia article says "Increased complexity of source code; greater risk for bugs"
05:03:54 <kmc> zzo38: your Famicom Hangman game uses RC4 as a random number generator?
05:04:08 <Sgeo_> Isn't that what code reuse is for? Does any non-library actually re-implement ropes?
05:05:27 <kmc> in the real world code reuse is not so much a thing
05:09:54 <zzo38> kmc: Yes it does use RC4 as a random number generator, and it runs several times per frame. It also uses the microphone, if there is one.
05:15:48 <zzo38> Is it good enough?
05:39:03 -!- ogrom has joined.
05:43:10 -!- hagb4rd has joined.
05:56:27 -!- hagb4rd has quit (Read error: Operation timed out).
06:00:17 -!- oerjan has quit (Quit: leaving).
06:13:18 <HackEgo> smlist: shachaf monqy elliott
06:13:33 <monqy> “a responsibility„
06:21:51 <Jafet> With great power comes great utility bills
06:29:47 -!- sirdancealo2 has joined.
06:31:20 -!- ogrom has quit (Quit: Left).
06:43:36 <kmc> 28.8 kilobonghits per second
06:44:34 <pikhq> I dunno, "kibibonghit" flows better.
06:44:53 <Jafet> Are those imperial or nautical bonghits
07:44:03 <zzo38> What would you use if *you* are making Famicom Hangman?
08:06:01 -!- impomatic has joined.
08:16:52 -!- azaq23 has joined.
08:18:59 -!- aloril has quit (Ping timeout: 276 seconds).
08:31:05 -!- aloril has joined.
08:46:14 -!- Bike has quit (Quit: leaving).
08:47:38 -!- Taneb has joined.
08:52:19 -!- Jafet has quit (Quit: Leaving.).
08:55:15 <Taneb> > let i = (:+) 0 in 4 + i 2
09:10:22 -!- nooga has joined.
09:10:42 -!- nooodl has joined.
09:11:02 -!- Taneb has quit (Quit: Leaving).
09:32:42 <myname> could someone explain me why n-cycle clears with n > 1 is any better than 1-cycled in bf joust?
09:35:11 <myname> i.e. i don't see the advantage of [-.] over [-].
09:45:01 -!- carado has joined.
09:56:55 -!- epicmonkey has joined.
09:59:24 -!- zzo38 has quit (Remote host closed the connection).
10:02:26 -!- hagb4rd has joined.
10:02:31 -!- nooga has quit (Ping timeout: 245 seconds).
10:09:42 -!- madbr has quit (Quit: Radiateur).
10:10:21 -!- nooga has joined.
10:14:47 -!- Frooxius has joined.
10:54:55 -!- cookienugget has quit.
10:56:35 -!- cookienugget has joined.
11:01:55 -!- monqy has quit (Quit: hello).
11:02:36 -!- Frooxius has quit (Ping timeout: 264 seconds).
11:04:34 -!- Phantom_Hoover has joined.
11:25:08 -!- nooga has quit (Ping timeout: 248 seconds).
11:25:25 -!- epicmonkey has quit (Ping timeout: 260 seconds).
11:32:32 -!- Sgeo_ has quit (Ping timeout: 250 seconds).
11:33:44 -!- hagb4rd has quit (Quit: hagb4rd).
11:52:48 -!- hagb4rd has joined.
11:56:14 -!- nooga has joined.
12:12:08 -!- cookienugget has quit (Ping timeout: 245 seconds).
12:17:00 -!- mroman_ has quit (Ping timeout: 264 seconds).
12:17:14 -!- mroman has joined.
12:27:10 -!- carado has quit (Quit: Leaving).
12:28:21 -!- carado has joined.
12:45:26 -!- nooga has quit (Ping timeout: 252 seconds).
12:45:40 -!- wareya_ has joined.
12:46:27 -!- cookienugget has joined.
12:47:58 -!- wareya has quit (Read error: Operation timed out).
12:51:14 -!- Arc_Koen has joined.
13:12:08 -!- Jafet has joined.
13:38:10 -!- Taneb has joined.
13:49:57 -!- DHeadshot has joined.
14:19:12 <ion> A fully functional in-browser clone of SimCity. http://tholman.com/playable-simcity-2013/
14:19:38 <Taneb> Not fully functional enough!
14:23:12 <hagb4rd> nightmare mode(tm) forever!
14:23:49 -!- epicmonkey has joined.
14:47:52 -!- carado has quit (Ping timeout: 256 seconds).
15:36:11 -!- nooga has joined.
15:53:10 -!- Taneb has quit (Ping timeout: 260 seconds).
15:54:31 -!- Taneb has joined.
16:05:51 -!- nooga has quit (Ping timeout: 245 seconds).
16:20:13 <Taneb> Is that :( at my Arrow explanation or my Applicative explanation
16:20:26 <Taneb> I'm presuming my Arrow explanation although my Applicative explanation did suck
16:23:50 <elliott> it was at "(<*>) takes a thing full of functions, and a thing full of inputs to the function, and applies the functions and the inputs in some way, then combines the rest of the things together
16:26:39 <Taneb> How is that inaccurate or misleading
16:28:30 <elliott> well "thing full of" and the plural...........
16:28:48 <elliott> you can have stuff where the "functions" branch on an undetermined amount of input etc. where the container analogy kinda breaks down
16:30:03 <Taneb> Analogies break down eventually
16:30:05 -!- Bike has joined.
16:30:55 <elliott> well imo it's a bad idea to give people things that will confuse them when they get to stuff like that because they've been given preconceptions...... especially when there's a lot of bad tutorials they can read if they really want analogies
16:31:00 <elliott> but it wasn't a really big frown
16:36:59 <Taneb> On another note, ekmett added me to another repo
16:37:51 -!- Sgeo has joined.
16:41:31 <nooodl> @hoogle [a] -> ([a],a,[a])
16:42:39 <elliott> i just sigh whenever i get another email about that now
16:43:13 -!- nooga has joined.
16:44:01 <Bike> :t \pivot:xs -> (filter (pivot <=) xs,pivot,filter (> pivot) xs)
16:44:08 <Bike> :t \(pivot:xs) -> (filter (pivot <=) xs,pivot,filter (> pivot) xs)
16:44:18 <Taneb> I have a feeling that I'm the only person who's been added to tables
16:45:05 <Bike> :t \(x:xs) -> (xs,x,xs) -- boring
16:45:39 <Taneb> :t \(x:xs) -> ([],x,xs) -- maybe what nooodl wants
16:46:29 <nooodl> hmm, i just realized i actually want
16:46:29 <nooodl> @hoogle Int -> [a] -> ([a],a,[a])
16:46:56 <nooodl> but splitAt is close enough
16:47:28 <nooodl> f = (\(a,b:c) -> (a,b,c)) . splitAt
16:50:00 -!- epicmonkey has quit (Ping timeout: 264 seconds).
16:52:51 <elliott> also that f is wrong but mainly dont do that
16:53:19 <nooodl> i need (.).(.) don't i
16:53:31 <nooodl> also what's wrong, i might not actually be doing the wrong thing anymore
16:54:08 <elliott> well using indices into lists is generally a bad idea
16:55:03 <nooodl> are you essentially saying "don't use (!!)" here
16:55:14 <Taneb> I agree with elliott
16:55:31 <nooodl> well.... i'm fairly sure i do need indices sorry
16:55:41 <Sgeo> Then use a structure other than lists
16:55:54 <Sgeo> I think that's the point
16:56:08 <nooodl> this is from that lyah exercise thingy
16:56:11 <Bike> naw O(n) access is the shit bro
16:56:27 <nooodl> it's asking me to write a binary search function on list that also logs using Writer
16:56:36 <nooodl> i know it's not something you'd actually do...
16:57:33 <elliott> well if the lyah exercises want you to do bad things then imho they're bad exercises!
16:57:44 <elliott> but i doubt you need indices to do binary search on []
16:57:49 <nooodl> also from the example it's apparent that the guy who made the exercise solved it wrong himself
16:58:13 <nooodl> how're you going to find the center without indices
16:58:44 <elliott> imo these exercises sound shit and you should stop doing them?
16:59:19 <nooodl> they're better than the alternative of "no exercises"
16:59:41 <Deewiant> Figure out how to use arrays and implement binary search with them
17:00:36 <nooodl> this solution probably wouldn't require a lot of changes to work with Array! i might do that
17:01:04 <elliott> too bad Array sucks too :(
17:01:35 <nooodl> what should i use then
17:01:49 <Bike> so what do you use if you want arrays, in haskell
17:01:53 <nooodl> man, this type signature is growing to be pretty large
17:01:55 <nooodl> binarySearch :: (Show a, Ord a, Eq a, Monoid b) => (a -> a -> b) -> a -> Array Int a -> Writer b Bool
17:02:04 <Deewiant> Vectors unless something new's come up since
17:02:22 <nooodl> why does it even say Ord a, Eq a
17:02:51 <Sgeo> How do arrays suck?
17:02:54 <Sgeo> Too many of them?
17:03:43 <elliott> Bike: vector or maybe repa or something but sometimes array is the only non-annoying option
17:03:47 <elliott> but then it's annoying because it's array
17:03:48 <Deewiant> http://u.arboreus.com/2011/03/how-to-choose-haskell-array-library.html has some stuff
17:04:18 <Bike> sorry "feature matrix"
17:04:40 <Bike> wait, why does it not have access time for Data.Array.
17:05:00 <nooodl> that sounds interesting
17:05:14 <Bike> do they just suck that much
17:05:30 <nooodl> import qualified Data.Vector as V
17:05:36 <nooodl> is this evil, it feels evil
17:06:41 <Deewiant> Bike: Possibly because the Ix class can be arbitrarily slow?
17:08:33 <Deewiant> Since it's immutable it doesn't have to copy anything, so of course
17:08:39 -!- epicmonkey has joined.
17:08:47 <nooodl> ugh who thought "snoc" was a good name for snoc
17:11:03 <elliott> Deewiant: (bad GC properties :( )
17:12:11 <Deewiant> elliott: Yeah GCs kinda suck like that
17:13:00 <elliott> there should be a way to do the copying of the "take"d elements when the original array gets freed
17:13:30 <Taneb> Hey, anyone here know the best way to get a C++11 <std::array> into Haskell
17:13:47 <Deewiant> Vector should be able to tell the GC that a given reference only needs a certain slice of the data
17:13:53 <elliott> more generally give up on binding C++ to haskell
17:15:09 -!- carado has joined.
17:16:02 <nooodl> yeah, "V.enumFromN 1 1000000000" is crashing ghci but i don't know what i expected
17:16:10 <nooodl> i mean. that's a pretty big vector
17:16:37 <Bike> do you need a billion element vector for something
17:16:48 <Deewiant> That's N gigabytes where N is the type's size (so probably Int's size)
17:17:07 <nooodl> testing this binary search function!!
17:17:35 <Bike> don't you think four gigabytes is a bit much for testing
17:18:19 <nooodl> ghc thinks so at least
17:18:44 <Jafet> nooodl: "maxBound :: Int"
17:19:28 <Jafet> nooodl : maxBound : Int
17:19:47 -!- AnotherTest has joined.
17:21:20 <nooodl> > (maxBound - minBound) :: Int
17:23:07 <tswett> Hi everyone hth. How's it going hth?
17:24:49 <tswett> Yesterday was the eighth hth.
17:26:07 <tswett> Now, to which URL should speaking post. Should it post to character/n/speak/? Seems like as good a URL as any.
17:36:35 -!- Frooxius has joined.
17:41:00 -!- carado has quit (Read error: Connection timed out).
17:41:50 -!- carado has joined.
17:46:56 -!- cookienugget has left.
17:47:17 -!- Taneb has quit (Ping timeout: 255 seconds).
17:48:43 -!- Taneb has joined.
18:12:49 -!- nooodl has quit (Ping timeout: 248 seconds).
18:26:42 -!- azaq23 has quit (Quit: Leaving.).
18:29:06 -!- FreeFull has quit (Quit: bbl).
19:05:26 <Taneb> Trivia: the first track of every single album I've bought on its release day opened at number 2 in the UK singles chart
19:08:23 <Taneb> Hexham? More like MAX HEH
19:09:01 <Bike> it's always a barrel of laughs up in hexham
19:10:57 <Bike> are those octopodes who won't shut up about star trek
19:12:28 <Taneb> By the way, those two messages from me were completely unrelated
19:13:28 <impomatic> How can I search the esoteric logs?
19:15:09 <elliott> you need to rsync them + grep
19:22:30 -!- Phantom_Hoover has quit (Ping timeout: 245 seconds).
19:27:35 -!- FreeFull has joined.
19:38:25 <impomatic> Hmmm... thanks. I only wondered the size of the Brainfuck Hello World I posted here...
19:42:34 -!- Phantom_Hoover has joined.
19:43:49 -!- nooodl has joined.
19:51:16 -!- Taneb has quit (Ping timeout: 245 seconds).
19:57:06 -!- epicmonkey has quit (Ping timeout: 264 seconds).
20:01:05 -!- Taneb has joined.
20:10:40 -!- oerjan has joined.
20:24:25 -!- sebbu has quit (Ping timeout: 260 seconds).
20:41:15 -!- AnotherTest has quit (Read error: Connection reset by peer).
20:41:26 -!- AnotherTest has joined.
20:41:27 -!- AnotherTest has quit (Client Quit).
20:51:32 <oerjan> hm it seems impossible with haskell types to generalize Control.Lens.Iso.mapping to take a Setter instead of just a Functor instance
20:52:34 <oerjan> because the setter needs to be used at two different types
20:53:55 <lambdabot> (Functor f1, Functor f, Profunctor p) => AnIso s t a b -> p (f a) (f1 (f b)) -> p (f s) (f1 (f t))
20:54:09 <oerjan> ...if those two types have a common rank-2 expression you are halfway to Functor already :(
20:54:49 <elliott> it could take two setters :P
20:55:31 <oerjan> yeah but that would ruin the point of my investigation, which was why wasn't mapping defined as mappingOf mapped in the first place
20:55:48 <Taneb> mappingOfOf mapped mapped
20:55:50 <oerjan> with great generalization possibilities
20:55:58 <Taneb> Clearly the way to go
20:56:47 <elliott> oerjan: it doesn't have to be all the way to Functor because it only has to work with f/f1, right?
20:56:52 <elliott> you could make it work with GADTs and stuff
20:57:31 <oerjan> elliott: f is the functor in question, f1 is the usual lens choosable one
20:58:02 -!- Phantom_Hoover has quit (Ping timeout: 256 seconds).
20:58:13 <oerjan> it needs to map f a -> f s and f t -> f s
20:59:11 <oerjan> * (a -> s) -> (f a -> f s) and (t -> b) -> (f t -> f b)
20:59:35 <oerjan> the definition of mapping is essentially mapping (iso sa bt) = iso (fmap sa) (fmap bt)
21:01:15 <oerjan> and you want to replace fmap by setter %~
21:03:24 <oerjan> :t mapped %~ view swapped
21:03:25 <lambdabot> (Functor f, Swapped p) => f (p a b) -> f (p b a)
21:04:51 <oerjan> that gives you a Getter only
21:05:01 -!- Phantom_Hoover has joined.
21:05:46 <lambdabot> MonadReader b m => AReview s t a b -> m t
21:05:59 <lambdabot> Gettable f => AReview s t a b -> (t -> f t) -> b -> f b
21:07:03 <Taneb> > review _Just 10 >>= \x -> lift [x]
21:07:05 <lambdabot> Couldn't match expected type `Data.Maybe.Maybe b0'
21:08:12 <Taneb> :t review _Just >>= \x -> lift [x]
21:08:14 <lambdabot> (MonadTrans t, MonadReader b (t [])) => t [] (Maybe b)
21:08:24 <Taneb> > runReaderT (review _Just >>= \x -> lift [x]) 10
21:09:18 -!- sebbu has joined.
21:09:18 -!- sebbu has quit (Changing host).
21:09:18 -!- sebbu has joined.
21:09:42 <lambdabot> MonadReader b m => AReview s t a b -> m t
21:11:36 <oerjan> 01:32:54 <myname> could someone explain me why n-cycle clears with n > 1 is any better than 1-cycled in bf joust?
21:11:39 <oerjan> 01:35:24 <myname> i.e. i don't see the advantage of [-.] over [-].
21:12:24 <oerjan> it's because to win, you have to make the flag 0 for _two_ consecutive turns
21:12:39 <myname> oerjan: you do with [-].
21:13:21 <oerjan> the opponent may be changing the flag during the ] step
21:13:56 <Taneb> But in [-], if he does you just exit the loop
21:13:57 <oerjan> not unless he _also_ did it in the . step
21:14:06 <Taneb> In [-.], you start decrementing it again
21:14:57 <oerjan> in [-.], if you reach the ] you _know_ your last - didn't succeed, so you just start again.
21:15:09 <myname> well, i'd test something like [[-].] then
21:16:12 <oerjan> i'm not a bfjoust expert, but i expect all of which works best depends on the opponent's defence strategy
21:16:20 <Sgeo> Does this statement help?
21:16:22 <Sgeo> "If L is a language, f is a function L->Trustfuck, and g is the inverse of f (that is, a function Trustfuck->L), then g(",+[-:,+]!") is a compiler for L, not a compiler for Trustfuck."
21:17:09 <Taneb> Have I ever said that Trustfuck is ridiculous?
21:17:14 <Sgeo> Taneb, how so?
21:17:22 <oerjan> Sgeo: it makes no mathematical sense to call that an inverse
21:17:50 <Taneb> Sgeo, really, it's your offhand comments about the consequences of Trustfuck that are ridiculous rather than the language itself
21:17:56 <Taneb> Which I don't understand due to lack of effort
21:18:36 <oerjan> it does not give f(g(x)) the same semantics as x, obviously, which is the point of the statement of course
21:19:01 <Taneb> Why do you need to mention f at all
21:19:04 <oerjan> or well, neither is semantics-preserving.
21:20:18 <Sgeo> If the semantics of ",+[-:,+]!" is "be a compiler for the current language" not "be a compiler for Trustfuck"
21:20:25 <Sgeo> Does that... make it work?
21:20:34 <Sgeo> I think that's what I'm trying to get at
21:20:52 <oerjan> no, because the current language doesn't use those characters at all, potentially :P
21:26:16 <oerjan> and there my brain ran out of energy again.
21:26:41 <Sgeo> I don't know if I know an accurate description
21:26:47 <Sgeo> I should think about Trustfuck-- a bit
21:28:14 <Sgeo> Hmm, this is a thought:
21:28:55 <Sgeo> A compiler written in Trustfuck for a language L does not compile to Trustfuck before doing !, the way I've described
21:29:09 <Sgeo> It compiles to... something else
21:29:48 <Sgeo> A language similar to Trustfuck except a different meaning for !
21:30:01 <oerjan> i would suggest trying to give a semantics of each language that makes no reference to more fundamental languages existing.
21:31:30 -!- Taneb has quit (Ping timeout: 276 seconds).
21:32:13 <oerjan> or maybe not more than two neighboring levels
21:32:16 -!- Taneb has joined.
21:32:58 <Sgeo> If L is a language, let L' be a language that is identical to Trustfuck except that ! accepts and compiles L code instead of Trustfuck code.
21:33:17 <Sgeo> Wait, I think ! should never be stated to compile Trustfuck code.
21:34:00 <Sgeo> Except along the same vein, L''s ! doesn't really take L code, does it? Because if L has an equvalent to !, then ...
21:41:12 -!- zzo38 has joined.
21:52:00 -!- monqy has joined.
22:00:07 <Sgeo> @hoogle runMaybeT
22:00:07 <lambdabot> Control.Monad.Trans.Maybe runMaybeT :: MaybeT m a -> m (Maybe a)
22:00:47 <Sgeo> erp, I wrote my code a bit backwards I think
22:01:10 <Sgeo> Ending up with a Maybe (IO ())
22:01:16 -!- kallisti_ has joined.
22:01:34 <Sgeo> @hoogle a (b c) -> b (a c)
22:01:35 <lambdabot> Data.Traversable sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
22:01:35 <lambdabot> Data.Traversable sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
22:01:35 <lambdabot> Test.QuickCheck.Gen promote :: Monad m => m (Gen a) -> Gen (m a)
22:01:37 -!- kallisti1 has joined.
22:03:24 -!- kallisti_ has quit (Client Quit).
22:03:25 -!- kallisti has quit (Quit: Lost terminal).
22:04:40 <Sgeo> @hoogle sequenceM
22:04:53 <Sgeo> Is Maybe traversable?
22:05:05 <Taneb> > sequence $ Just "hello"
22:05:07 <lambdabot> Couldn't match expected type `[m0 a0]'
22:05:13 <Taneb> > Data.Traversable.sequence $ Just "hello"
22:05:15 <lambdabot> [Just 'h',Just 'e',Just 'l',Just 'l',Just 'o']
22:06:38 <Sgeo> Doesn't quite seem to be working for me
22:07:29 <Sgeo> () <$ T.sequence mSendIt
22:07:36 <Sgeo> I think I have just gone overboard
22:07:44 <Sgeo> Doing that instead of putting a return () at the end
22:07:48 <Taneb> I may be the first person to ever have compared Order of the Stick to the University of Birmingham
22:08:36 <elliott> Sgeo: that's Control.Monad.void
22:08:50 <lambdabot> Foreign.Marshal.Error void :: IO a -> IO ()
22:08:50 <lambdabot> Control.Monad void :: Functor f => f a -> f ()
22:09:32 <Sgeo> Pairs are a functor?
22:09:54 <Taneb> instance Functor ((,) a) where fmap f (a, b) = (a, f b)
22:10:11 <Taneb> If the first argument is a monoid I think they're a monad
22:10:43 <Taneb> instance Monoid a => Monad ((,) a) where return = (,) mempty; (a, b) >>= f = let (a', c) = f b in (a `mappend` a', c)
22:11:14 <monqy> Sgeo: there are lots of instances. sorta wack to say pairs "are" a functor.............. especially since in some cases it's partially applied pairs
22:11:18 <monqy> and in other cases
22:11:23 <monqy> it's certain sortsa pairs
22:11:30 <monqy> pairs with only one sorta thing in them
22:11:37 <Taneb> data Pair a = Pair a a
22:12:14 <Taneb> instance Functor Pair where fmap f (Pair a a) = Pair (f a) (f a)
22:12:39 <Taneb> Modulo stupid names that overlap
22:16:13 <Taneb> Sgeo, how's that IRC thingy you're doing going
22:16:39 <Sgeo> Some ugly parts
22:16:53 <Sgeo> And config stuff is hard-coded
22:16:58 <Sgeo> But it's meant to be a simple bot
22:17:31 <Taneb> Might make a bot that evaluates Piet
22:17:40 <Taneb> Rather than one written in piet
22:18:18 <Sgeo> http://hpaste.org/83768
22:22:23 <Sgeo> Just realized that there's some unneeded code there
22:22:28 <Arc_Koen> Sgeo: are you making an irc bot in piet?
22:22:35 <Sgeo> Just pretrend lines 25-26 don't exist
22:32:01 -!- sebbu has quit (Ping timeout: 248 seconds).
22:42:11 -!- ais523 has joined.
22:49:44 -!- TeruFSX has joined.
22:53:00 -!- Taneb has quit (Ping timeout: 252 seconds).
22:53:34 -!- Taneb has joined.
22:53:40 <Phantom_Hoover> question of the day: what kind of sane person uses lowercase xi
22:54:40 <monqy> i see lowercase xi every so often
22:54:49 <monqy> but uppercase xi, now that's crazy
22:56:34 <elliott> uppercase xi is ok as long as it's not sans serif
22:56:48 <elliott> uppercase sans serif xi is the abomination unto nature
22:57:34 <elliott> well thankfully the greeks are fucking dead
22:57:37 <elliott> so you don't have to write greek any more
22:59:30 <Phantom_Hoover> you realise that in that case everyone will just write the normal alphabet in weird ways
22:59:32 <nooodl> you have to think of it in steps. ς → ζ → ξ
23:00:05 <Taneb> The greeks aren't dead, just economically oh no'd
23:00:12 <olsner> ah, you meant xi the greek letter? reminds me of an old calculus lecturer who used the same squiggle for every greek letter, ln and cos
23:00:29 <Taneb> olsner, sound awful
23:01:18 <olsner> not all bad though, the unreadable formulas does sort of force you to pay attention to what's being written and what it means
23:01:21 <nooodl> ς is just an s. ζ is just ς with a line above it. ξ is just ζ with a dent in it
23:02:04 <Phantom_Hoover> he writes beta as what is for all intents and purposes an ordinary b
23:03:23 <olsner> i.e. he uses the ordinary b instead of the latin b?
23:04:21 <Bike> Is return being in Monad rather than Functor a quirk?
23:04:37 <Taneb> It should be in Applicative if anywhere
23:04:42 <Taneb> Functors do NOT have return
23:05:06 <elliott> Monad is detached from the rest of the hierarchy for historical reasons
23:05:11 <Bike> Yes, but I want to know if this is a mess or something I'm misunderstanding.
23:05:20 <elliott> "pure" in Applicative is what return should be
23:05:30 -!- TeruFSX has quit (Ping timeout: 264 seconds).
23:05:35 <Bike> Since I thought mathematical functors mapped objects in addition to morphisms.
23:05:39 <Taneb> Bike, not all functors have an equivalent to return
23:05:48 <elliott> an object in Hask is a *type*
23:05:54 <elliott> and Functor models endofunctors (functors Hask -> Hask)
23:05:56 <Taneb> What's return :: a -> (Void, a)?
23:06:07 <elliott> so if you have a Functor instance f
23:06:15 <elliott> then f Int is mapping the object Int
23:06:21 <elliott> and fmap maps morphisms (functions)
23:06:35 <Bike> and fmap (Int -> Int) maps the morphism.
23:06:51 <elliott> i.e. a functor takes the morphism f : A -> B to F(f) : F(A) -> F(B), where F(X) is mapping the object X
23:07:00 <elliott> Bike: erm, that's not valid syntax, but sure
23:07:14 <elliott> ...in this case, a functor takes the morphism f :: Int -> String to fmap f :: F Int -> F String
23:07:35 <Bike> ok, that makes sense.
23:08:08 <elliott> (actually Functor models something ridiculous like functors mapping Hask to the subcategory of Hask where only types of the form (f a) are objects or such)
23:08:12 <elliott> (but that doesn't really matter)
23:08:24 <Bike> Sounds elegant.
23:10:08 <fungot> Taneb atriq Ngevd Fiora nortti Sgeo ThatOtherPerson alot
23:10:23 <Sgeo> erm, false alarm possibly
23:10:39 <monqy> you dont want to know
23:10:43 <Taneb> nooodl, notifying about Homestuck updates
23:10:45 <Bike> annoying s h a c h a f mostly?
23:11:03 -!- sebbu has joined.
23:11:03 -!- sebbu has quit (Changing host).
23:11:03 -!- sebbu has joined.
23:11:18 <nooodl> the new homestuck updates look really boring
23:11:24 <Taneb> Bike, nah, he's not on the ^list
23:11:47 <nooodl> by new i mean anything that happened in the past 1-2 years
23:11:59 <monqy> it sort of amazes me that people read homestuck
23:12:18 <Taneb> Although cf his HackEgo wisdom
23:12:55 <Fiora> the past 1-2 years have been pretty wonderful
23:13:07 <Fiora> though I guess still not the wonderfulness of act 5 and karkat arguing with himself
23:14:24 <Phantom_Hoover> the best of homestuck for me was when it was about the original 4
23:14:35 <Bike> shit on your desk
23:14:56 <Phantom_Hoover> hivebent was jut a chore for me since i really wanted to know e.g. where jade was going to land
23:15:08 <Fiora> I really do like the original 4 humans, yeah. I never really got into the alpha kids much
23:15:20 <Taneb> I quite like the Alpha kids
23:15:22 <Fiora> and jade is still my favorite is and john is still the most adorable dork and dave is still awesome
23:15:33 <Taneb> Jake's my favourite now
23:15:52 <monqy> nooodl: what have you started
23:16:01 <Fiora> but hivebent had such wonderful characters too. like karkat
23:25:21 -!- sebbu has quit (Ping timeout: 248 seconds).
23:41:55 <Sgeo> wtf http://perl8.org/
23:42:05 <Sgeo> (Someone has perl8.org pointing to Scala)
23:42:21 <Bike> programming language jokes!
23:53:43 <tromp_> better than www.perl5.org
23:54:19 <Sgeo> How much cheating would be acceptable in a Feather-like language?
23:55:11 <monqy> not only may you not cheat but you must do community service to make up for all the stupid time travel jokes you're causing
23:58:22 <Sgeo> Compiled languages often have a bootstrap process, in which, say, a compiler for L written in L is compiled using a compiler for L written in another language. Can this process be made a part of the language somehow?
23:59:29 <olsner> just write the compiler in L, like all those C compilers written in C
23:59:34 <Bike> what kind of self-respecting language acknowledges other languages' existence? that sounds like step one down a path to interoperability son