00:08:00 <jix_> hmm to implement this i need a type checker....
00:09:42 <jix_> hmmm defining application for something that isn't a function makes this unnice
00:16:05 <jix_> ok i need recursive types or a builtin fixed point operator :/
00:16:49 <ehird> just compile to haskell :p
00:16:56 <jix_> haskell lacks recursive types
00:17:18 <jix_> at least without some extension... not sure about that
00:17:56 <ehird> jix_: haskell has a built-in fixed point operator
00:17:59 <ehird> jix_: you could compile to ocaml
00:18:06 <ehird> ofc then you lose type safety
00:18:21 <jix_> ehird: yeah but doing a fixed point operator is trivial
00:18:29 <jix_> (when writing an interpreter)
00:18:32 <oerjan> jix_: for recursive types in haskell, use newtype
00:19:26 <jix_> i could of course use runtime typechecking....
00:19:30 <jix_> but that sucks
00:19:31 * ehird decides to implement something in ocaml.
00:19:35 <ehird> an esolang that is
00:25:23 <Ilari> One idea for non-tc tarpit language: Bounded-loop language with conway arrow operator. :-)
00:30:42 <Ilari> And Conway arrow gets some crazy large numbers fast. Especially if you chain them. Three-arrow chains rapidly produce values bigger than even Graham's number (or even "xkcd number").
00:37:31 -!- Arrogant has joined.
00:40:21 <ehird> Ilari: A(g64,g64) arrow chains, bitch!
00:41:03 <Arrogant> I haven't been here for like a year
00:41:49 <ehird> Arrogant: the usual, most likely
00:43:10 <Arrogant> so... brainfuck and like 50 variations?
00:43:49 <ehird> Arrogant: we may have more of a functional bent nowadays, although perhaps not as recently as a year ago
00:44:09 <Arrogant> I think a year might've been an optimistic estimate
00:44:21 -!- Dewio has joined.
00:44:30 <ehird> which doesn't work yet.
00:44:36 <pikhq> Oh, and EgoBot has been rewritten.
00:44:43 <oerjan> also the occasional befunge, right fungot?
00:44:44 <fungot> oerjan: and you have to learn more about scheme and he muttered it again, this is neither politics nor fnord.
00:45:04 <ehird> (Arrogant: in case you don't know who fungot is, here's a file that no man should wot of: http://zem.fi/~fis/fungot.b98.txt)
00:45:04 <fungot> ehird: the structure is assumed to mean fnord)? i
00:46:00 <GregorR> fungot: Yes fungot, the structures IS assumed to mean fnord). i
00:46:01 <fungot> GregorR: go and ping riastradh already said that
00:46:01 <ehird> oerjan: can you do mutually recursive functions in ocaml without an .mli?
00:46:24 <ehird> !slashes /foo/bar/foobar
00:46:30 <oerjan> ehird: put them in the same val rec block with and between, iirc
00:46:33 <ehird> !slashes /foo/bar/foo/bar/foo/bar
00:46:43 <ehird> 'sat an infinite loop ey?
00:47:15 <ehird> /foo/bar/foo/bar/foo/bar →
00:47:51 <oerjan> /bar/bar/bar -> inf loop
00:48:00 <Arrogant> ehird, that is a rather horrific file to be sure
00:48:02 <ehird> a replacement doesn't consider itself
00:48:08 <ehird> Arrogant: it's fungot's source!
00:48:08 <fungot> ehird: he's french, jcowan. they can't type much with qwerty without suffering pain.)
00:50:33 <oerjan> at least in my implementation. it's not like it checks for any special cases....
00:50:44 <ehird> oerjan: mine scanned after, you see
00:50:46 <ehird> as per the optimization
00:51:15 <oerjan> note that /bar/barf/bar is _definitely_ an infinite loop
00:51:46 <oerjan> by the specification, the substitution is repeated on the first instance until the source string no longer occurs
00:52:16 <ehird> bsmntbombgirl: why
00:52:37 <bsmntbombgirl> ehird: because i can read from it 3 times faster than i can write to anything!
00:52:51 <ehird> bsmntbombgirl: buy one of the crappy-random-access-but-large-storage ssds
00:52:55 <ehird> they have fast sequential speed :P
00:55:50 -!- Dewi has quit (Read error: 101 (Network is unreachable)).
00:59:04 <ehird> [[“C programmers” really program not in C, but in the purely functional language cpp. As with any purely functional language, cpp consists only of (nestable) expressions, not statements. Now here’s the clever part: when evaluated (not executed), a cpp expression yields a (pure) value of type C, which is an ADT (abstract type) that represents imperative programs. That value of type C is then executed (not evaluated) by the cpp language’s RTS (run-
00:59:07 <ehird> time system). As a clever optimization, cpp’s RTS actually includes a code generator, considerably improving performance over more naïve implementations of the C abstract data type. ]]
01:02:58 <pikhq> I didn't know that CPP was purely functional.
01:03:04 <ehird> pikhq: modulo #undef :)
01:03:27 <pikhq> Well, if you ignore undef, then yes, yes it is.
01:04:25 <ehird> http://conal.net/blog/posts/the-c-language-is-purely-functional/
01:04:30 <ehird> "or char *, for you type theorists, using a notation from Kleene"
01:05:42 <augur> ehird: i think thats actually the origin of the * notation. not that it matters, since a char* is not a kleene star of chars but
01:06:56 <augur> if C is purely functional, then why bother with haskell?
01:07:04 <ehird> augur: the post's a joke yo.
01:07:14 -!- inurinternet has quit (No route to host).
01:07:16 <GregorR> ehird: Your MOM is a joke, yo.
01:07:22 <ehird> augur: read the conclusion
01:07:26 <ehird> it's argumentum ad absurdum
01:07:46 -!- Dewio has changed nick to Dewi.
01:08:19 <augur> but i dont agree with his argument in the first place! D:
01:08:26 <ehird> his argument is technically true
01:08:36 <augur> because people dont code in cpp
01:08:50 * ehird hands augur an "I Didn't Read The Post!" badge
01:09:00 <augur> ehird, i read the post when it was first posted.
01:09:12 <pikhq> Someone wrote "Hunt the Wumpus" in CPP for IOCCC, IIRC.
01:09:21 <ehird> so did your mom, though
01:09:26 <augur> how do people code in cpp?
01:09:28 <GregorR> Of note: CPP isn't TC, so this is all silliness :P
01:09:33 <ehird> GregorR: Nor did you!
01:09:53 <pikhq> GregorR: It is if you assume iterated executions.
01:09:58 * Warrigal hands himself an "I Didn't Read The Post!" badge.
01:10:12 <GregorR> pikhq: Which you don't, because that's not how it's used.
01:10:13 <Warrigal> The post fails to specify what a value of type cpp returns upon execution.
01:10:48 <Warrigal> In particular, there's quite a lot that can't be bothered to finish this sentence, so I'm going to do something else.
01:11:18 <pikhq> GregorR: Anyways, CPP is still purely functional. It just doesn't allow recursion. :P
01:11:34 <pikhq> (making it the single most useless purely functional language I know of)
01:11:41 <GregorR> Yeah, it's purely function and non-TC.
01:11:55 -!- upyr[emacs] has quit (Remote closed the connection).
01:12:07 <augur> oh i see what you mean.
01:12:16 <augur> slereah_: only some algebras!
01:12:35 <pikhq> My computer algebra system is TC!
01:12:37 <GregorR> "Algebra", in the usual formulation of the word, does not include functions, and so cannot include recursion.
01:12:44 <augur> actually, i dont think any algebra is TC, since an algebra is a formal system, not an algorithm for computation
01:12:44 <Warrigal> Algebra has infinite storage space.
01:12:44 <pikhq> (it is in fact a Lisp!)
01:13:00 <Warrigal> Formal systems can be TC or not, surely.
01:13:10 <GregorR> Your mom can be TC or not, surely.
01:13:24 <ehird> YOUR FACE CAN BE JFHIUDwh5iu3oi 6o56opsai35f893q90-[[[q
01:13:25 <Slereah_> My mom doesn't have infinite memory
01:13:29 <Warrigal> Like if there's a function from Turing machine to sentence computable by an FSA where the sentence is derivable if and only if the machine halts.
01:13:30 <augur> Slereah_: not really. First order and second order logic are not "turing complete". its meaningless to apply that phrase to them.
01:13:38 <pikhq> GregorR: There is some confusion, though, since most people are introduced to functions in their "Algebra" course.
01:14:08 <Slereah_> augur : But you can define algorithm in logic :o
01:14:19 <Warrigal> I was introduced to calculus in my Pre-Calculus course. That was weird.
01:14:21 <augur> im pretty sure it wasnt
01:14:30 <augur> the incompleteness theory isnt about algorithms
01:14:42 <ehird> he's right you know
01:14:43 <pikhq> Warrigal: I was introduced to the calculus of derivatives in my pre-calc class, as well.
01:14:47 <Slereah_> Half of the paper is about them
01:15:00 <Slereah_> With recursive functions and shit
01:15:04 <pikhq> But for some reason, we were only taught how to take the derivative of polynomials.
01:15:16 <Warrigal> We were taught the definition of a derivative.
01:15:17 <pikhq> I guess they wanted to cover the trivial case?
01:15:24 -!- inurinternet has joined.
01:15:26 <GregorR> My disdain for this conversation brings about many childish "your mom" jokes. But then again, your MOM'S disdain for this conversation brings about many childish "your mom" jokes.
01:15:30 <Warrigal> So, how do you take the derivative of x^2 + 3x + 4, everyone?
01:16:01 <pikhq> Define "definition". Formal defintion involving either infinitisimals or \lim?
01:16:02 <GregorR> With milk and two scoops of sugar.
01:16:12 <pikhq> Or just "It's the slope of the tangent line"?
01:16:22 <Warrigal> Plug it into the definition: lim_(h->0) ((x+h)^2 + 3(x+h) + 4 - x^2 - 3x - 4)/h
01:16:49 <pikhq> Slereah_: ... Open sets? Really?
01:17:03 <Warrigal> Multiply it out: lim_(h->0) (x^2 + 2xh + h^2 + 3x + 3h + 4 - x^2 - 3x - 4)/h
01:17:04 <Slereah_> I seem to recall analysis stuff defined with topology
01:17:18 * pikhq doesn't know much of set theory; I just got through calc 3, man!
01:17:19 <Slereah_> Of course, the definitions are pretty much the same as limits
01:17:27 <Slereah_> Except it employs the local vocabulary
01:17:27 <Warrigal> Cancel: lim_(h->0) (2xh + h^2 + 3h)/h
01:17:43 <Warrigal> Cancel: lim_(h->0) (2x + h + 3)
01:18:35 <Warrigal> I didn't do that. I used the calculus I knew that everyone else didn't.
01:19:53 <ehird> How to take the derivative of (x^2 + 3x + 4) for lazies:
01:19:54 <ehird> In[11]:= D[x^2 + 3 x + 4, x]
01:20:12 <Warrigal> Unfortunately, Mathematica isn't allowed on the AP test.
01:20:24 <Warrigal> Hmm, will Mathematica take a Lagrange error bound?
01:21:07 <ehird> it'll take your mom Warrigal
01:21:26 <oerjan> nonstandard analysis monads, that is
01:21:27 <Warrigal> They let you show that the derivative of dy/dx with respect to x is d^2y/dx^2 - dy/dx.
01:22:30 <pikhq> Y'know, I'd really like to learn Haskell. Unfortunately, it seems that I don't know enough math to understand it.
01:23:46 <lament> pikhq: you don't need any math...
01:24:15 <ehird> Haskell is just functional programming.
01:24:20 <ehird> It just happens to have parallels to category theory.
01:24:41 <ehird> i'm pretty much mathtarded and i grok haskell
01:24:47 * pikhq is coming from a heavy string of imperative languages. Mind blowing begin now
01:25:04 <ehird> pikhq: may I interest you in the airline food, Scheme?
01:25:11 <ehird> (Note: is not disgusting like airline food)
01:25:13 <pikhq> Fine, I'll struggle through it. Mind-blowing can't be too bad for me, can it?
01:25:28 <ehird> Have another analogy:
01:25:38 <Warrigal> Mind blowing is definitely good for a person.
01:25:42 <ehird> Scheme. It's Haskell's gateway drug.
01:25:43 <Warrigal> Mind-blowing, on the other hand, is an adjective.
01:25:59 <oerjan> pikhq: when brain juice starts pouring out of your nose, it may be time to take a break
01:26:57 <oerjan> it's a fairly rare side-effect of haskell, though. not to be confused with nose-bleeding.
01:27:50 <oerjan> (all haskell side-effects are rare)
01:28:05 <ehird> pikhq: http://learnyouahaskell.com/ is probably the best tutorial for an imperativer
01:28:17 <ehird> (if you can stand the style, i love it)
01:28:40 <ehird> pikhq: but yeah, it uses basically no mathematics and doesn't tell you false rubbish only to correct it later
01:32:31 <pikhq> oerjan: I thought it was purely functional? :P
01:33:15 <fungot> monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads monads mo ...too much output!
01:33:47 <GregorR> monads monads monads monads monads monads monads monads monads monads monads monads IO IO
01:35:11 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
01:35:17 <EgoBot> userinterps: Users can add interpreters written in any of the languages in !help languages. See !help addinterp, delinterp, show | !userinterps. List interpreters added with !addinterp.
01:35:59 <Warrigal> !addinterp svedeesh sh chef | fmt -w500
01:35:59 <EgoBot> Interpreter svedeesh installed.
01:36:05 <ehird> pikhq: btw, visit #haskell. we don't bite.
01:36:08 <Gracenotes> ugh. removing accidentally mutually recursive directories is annoying
01:36:14 <Warrigal> !addinterp sfedeesh sh chef | fmt -w500
01:36:14 <EgoBot> Interpreter sfedeesh installed.
01:36:26 <GregorR> Gracenotes: ... creating mutually recursive directories sounds like quite the hat tric.
01:36:36 <Gracenotes> simple as rm -rfv, but still, the log is quite verbose
01:36:46 <Gracenotes> removed directory: 'a/b/a/b/a/b/a/b/a/b'
01:36:48 <Gracenotes> removed directory: 'a/b/a/b/a/b/a/b/a'
01:37:12 <Gracenotes> I'm guessing there's a maximum recursion depth that made the whole thing terminate okay
01:37:29 <GregorR> Gracenotes: How did you accomplish this feat in the first place?
01:37:52 <GregorR> Linux+ext3 doesn't let you hardlink directories IIRC
01:38:15 <GregorR> (Where by "you" I mean "even root")
01:38:18 <Gracenotes> GregorR: not sure. I think I accidentally dragged a directory in nautilus into a folder in its directory
01:38:20 <Warrigal> Well, then, use a different filesystem.
01:38:35 <Gracenotes> by "directory in nautilus", I mean a part of its gui
01:38:54 <Gracenotes> the bar at the top. I'm using ext3 by the way
01:39:20 <Warrigal> a = mkDirectory "a" [mkDirectory "b" [a]]
01:40:12 <GregorR> If, using some filesystem that allows you, you create two mutually recursive directories, can you unlink the top one from its original path and allow them to exist, both with one reference, defying your filesystem's simple reference counting garbage collector? :P
01:40:50 <Gracenotes> okay. Doing find on these directories does terminate
01:41:02 <pikhq> I'd assume this is why you can't hardlink directories. :P
01:41:13 <GregorR> Yeah, I'm thinkin' it just is copying into itself at some arbitarily silly depth.
01:42:00 <Gracenotes> according to Haskell, the number of slashes in the longest path is 994
01:42:06 <ehird> ln: `a': hard link not allowed for directory
01:42:19 <ehird> can you morph a file into a directory in-place?
01:42:29 <GregorR> Uh, no? Not without a hexeditor :P
01:42:59 <GregorR> Because there's no interface in the filesystem's API to allow you to?
01:43:05 <pikhq> Maybe with libext2?
01:43:10 <ehird> pikhq: for HFS+ :P
01:43:22 <GregorR> I vote you use a hexeditor.
01:43:22 <ehird> [ehird:~/Junk] % cd a/b/a/b/
01:43:23 <ehird> my_cd:pushd: too many levels of symbolic links: a/b/a/b/
01:43:28 <ehird> okay, first of all
01:43:36 <ehird> I'm not opening a 256GB file in any editor then searching it
01:43:46 <ehird> can you even do that to a mounted filesystem?
01:43:52 <ehird> i don't have any backups so fuck that
01:43:53 <pikhq> third, why is cd redefined to pushd?
01:44:08 <Gracenotes> okay, here's the rm log. http://67.223.225.106/weird.txt
01:44:13 <ehird> my_cd() { dirs=($(dirs)); if [[ ! -z $1 && $1 != $dirs[1] ]]; then pushd $*; fi }
01:44:13 <ehird> setopt pushd_silent
01:44:18 <Gracenotes> nothing too exciting. but rm did produce it
01:44:21 <ehird> pikhq: So I can jump around my "directory history".
01:44:22 <GregorR> /home/gregor/test/loopy/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:44:45 <ehird> although i should add a fwd
01:44:54 <ehird> [ehird:~/Junk/a/b] % cd a
01:44:54 <ehird> my_cd:pushd: too many levels of symbolic links: a
01:45:21 <pikhq> ehird: Perhaps by having bk pop to some other stack. :P
01:45:21 <ehird> [ehird:~/Junk/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b] %
01:45:54 <ehird> pikhq: GregorR: Gracenotes:
01:45:56 <ehird> [ehird:~/Junk/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b] % cd a/b/a/b/a/b/a/b/a/b/a/b/a/b
01:45:59 <ehird> [ehird:~/Junk/a/b] %
01:46:02 <ehird> WHAT DOES IT MEAN????????????
01:46:10 <ehird> I WAS TRANSPORTED ALL THE WAY BACK!
01:46:49 <ehird> ls: a/b/a: not listing already-listed directory
01:47:09 <ehird> `run for i in $(seq 1000); do cd a; done
01:47:25 <HackEgo> a \ bin \ paste \ quotes \ share \ tmpdir.8746
01:47:38 <ehird> `run for i in $(seq 10); do cd a; done
01:47:48 <ehird> `run for i in $(seq 10); do cd a; done; pwd
01:47:51 -!- augur has quit ("Leaving...").
01:48:07 <GregorR> `run ( while true; do cd a; done ) 2>&1 | tail -n 2
01:48:22 * GregorR just assumes that'll fail at some point :P
01:48:26 <ehird> % for i in $(seq 1000); do mkdir a; cd a; done
01:48:33 <ehird> i can has break my filesystem?
01:49:07 <GregorR> $ while true; do mkdir a; cd a; done
01:49:17 <GregorR> (That makes me more hardcore than you)
01:49:31 <ehird> Uh, I think I'm running out of disk.
01:49:43 <GregorR> /home/gregor/test/baddir/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:49:43 <GregorR> /a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:49:57 <GregorR> /home/gregor/test/baddir/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:49:57 <GregorR> /a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:49:58 <GregorR> /a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:50:03 <GregorR> /a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:50:08 <GregorR> /a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a
01:50:36 <ehird> [ehird:~/Junk/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:50:38 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:50:41 <pikhq> I'm not even all that far in, but this is damned cool. :)
01:50:43 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:50:48 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:50:53 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a] %
01:50:55 <GregorR> I thought there was a maximum path length limit :P
01:51:30 <ehird> mkdir: cannot create directory `a': File exists
01:51:40 <pikhq> GregorR: 2.6 eliminated it.
01:51:51 <pikhq> The maximum path length is 'how much memory can be allocated'.
01:52:09 <ehird> mine is going slowly
01:52:11 <ehird> i wonder if i can...
01:52:25 * pikhq just got to list comprehensions
01:52:46 <ehird> pikhq: just wait for the culture shock :)
01:53:12 <pikhq> This is just "OMFG. Sweet." so far.
01:53:13 <GregorR> Argh, I tried to stop it at exactly 2000
01:54:01 * ehird types cd a/ and holds down tab.
01:54:04 <ehird> it gets progressively slower XD
01:54:05 <GregorR> 0.00user 0.04system 0:00.05elapsed 96PU (0avgtext+0avgdata 0maxresident)k
01:54:05 <GregorR> 0inputs+0outputs (0major+252minor)pagefaults 0swaps
01:54:22 <GregorR> It seems to actually be gone D-8
01:54:37 <GregorR> I guess the filesystem does all its GC in the background.
01:54:55 <ehird> Your filesystem, remember, is insanely optimized :P
01:55:18 <GregorR> Whereas yours was intended for m68k-based systems that used "\r" for newlines? :P
01:55:29 <Asztal> P:\BadDir\a\a\a\a\a\a\a\a\a\a\a\a\a\a\a\a\a\a>cd a\a\a\a\a\a\a\a\a\a\a\a\a\a\
01:55:31 <Asztal> The name of the file cannot be resolved by the system.
01:55:46 <ehird> GregorR: Yes, because OS X totally uses the OS Classic codebase :P
01:55:56 <ehird> Asztal: WINDOWS FAG
01:56:29 <GregorR> ehird: "Filesystem" is an ambiguous term, I was using it to refer to the definition of the data format, not the driver.
01:56:34 <pikhq> GregorR: ext3 is reference counted. ;)
01:56:58 <GregorR> I count one reference to it RIGHT NOW
01:56:58 <pikhq> Also, HFS+ has little to do with OS Classic.
01:56:59 * ehird listens to his disk spin.
01:57:33 <pikhq> Oh, it was first used for OS 8.1. Never mind.
01:57:48 <pikhq> Nothing to do with m68k, though. ;)
01:58:03 <GregorR> Well, it's based on HFS (at least in spirit) *shrugs*
01:58:05 <ehird> HFS+ rocks, anyway.
01:58:19 <GregorR> So does your MOM. ... in bed?
01:59:07 <ehird> ^C% [ehird:~/Junk/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:11 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:16 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:21 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:26 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:31 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:36 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/
01:59:41 <ehird> a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a] %
01:59:47 <ehird> [ehird:~/Junk] % time rm -rf a
01:59:49 <ehird> rm -rf a 0.07s user 0.35s system 83% cpu 0.507 total
02:04:35 <ehird> bsmntbombgirl: what
02:04:48 -!- CESSMASTER has joined.
02:06:11 <Gracenotes> what comes after dichotomy and trichotomy?
02:06:46 * oerjan wondered about that yesterday
02:07:15 <oerjan> darn net is molasses again
02:07:38 <Gracenotes> I always confuse the ordinal prefixes. for four, there's both tetra and quad
02:07:57 <Gracenotes> then there's twice, thrice, and quarce
02:08:00 <oerjan> tetra is greek, like di
02:08:12 <Gracenotes> and what's quad and everything in its sequence?
02:08:53 <Gracenotes> once, twice, thrice, quarce, quince, sense, septence, octence, novence...
02:10:06 <oerjan> undecim, duodecim, tredecim
02:10:23 <Gracenotes> but that's not of the same ordinal forms twice/thrice are :)
02:10:47 <Gracenotes> hm. http://en.wiktionary.org/wiki/Wiktionary_talk:List_of_protologisms#More_number_words
02:10:56 <oerjan> true, but those were weirdly germanic/romance mixes?
02:15:06 * oerjan wonders who in the neighborhood is downloading HD movies
02:20:56 <Gracenotes> hm. time to shred a 500-MB directory with 150-something files, just for the fun of it
02:24:00 -!- GreaseMonkey has joined.
02:24:28 <oerjan> at least spider solitaire is not slow...
02:26:39 <Arrogant> alright, successful installation of a 500gb seagate hard drive into my macbook pro
02:31:27 <pikhq> Okay, so far I have gone from "that's kinda cool" to "Haskell is the manifestation of all that is good".
02:31:37 <pikhq> Brain breaking should set in soon, I think.
02:32:55 <Asztal> if it doesn't, http://hackage.haskell.org/cgi-bin/hackage-scripts/package/category-extras might help
02:35:12 <oerjan> edwardk sometimes used to come here, iirc
02:36:04 <oerjan> his languages were a little more advanced than the usual discussion ;)
02:50:18 * pikhq almost has a Haskell interpreter.
02:53:52 <pikhq> GHC takes a while to build.
02:54:01 <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
02:55:32 <oerjan> GregorR gave up adding ghc to EgoBot
02:56:04 <oerjan> lambdabot is where you want to go for that
02:56:22 <GregorR> I couldn't figure out how to make it just run code and give the effing output, no header, no prompt, just output.
02:56:49 <oerjan> GregorR: (1) runhaskell (2) ghc -e
02:57:21 <oerjan> i think it's a script, anyway it comes with ghc
02:58:01 <oerjan> runhaskell takes a whole Main module, ghc -e takes an expression
02:58:04 <GregorR> Oh right, but that requires you have a main function. You can't just give it arbitrary code. I'd like to have it work either way, ideally.
02:58:39 <pikhq> Say, is there a haskell-mode?
02:59:19 <oerjan> i hear haskell is a bit hard on automatic indentation though
02:59:35 <oerjan> iirc you sometimes have to cycle between alternatives
03:00:55 * GregorR has never had any issues with vim's automatic indentation WRT Haskell.
03:02:02 * oerjan has never tried to set vim to do anything more clever than the default for haskell (same indentation as previous line, except automatic comment continuation afaict)
03:03:13 <GregorR> !haskell putStr "Hello, world!\n"
03:03:20 <GregorR> !haskell main = putStr "Hello, world!\n"
03:03:22 <EgoBot> Warning: ignoring unrecognised input `/tmp/input.9739'
03:03:25 <oerjan> but i understand it trips up emacs users who are used to return always ending in the right spot
03:03:47 <GregorR> Is the input unrecognized because it doesn't have a fekking .hs or what?
03:03:51 <oerjan> GregorR: i think you need a flag for it to recognize anything not ending with .hs .lhs
03:11:51 <oerjan> "Causes all files following this option on the command line to be processed as if they had the suffix suffix. For example, to compile a Haskell module in the file M.my-hs, use ghc -c -x hs M.my-hs.
03:12:22 <GregorR> !haskell main = putStr "Hello, world!\n"
03:12:55 <GregorR> <EgoBot> Failed to load interface for `Main':
03:12:55 <GregorR> <EgoBot> Use -v to see a list of the files searched for.
03:13:56 <oerjan> what's the actual command line?
03:14:33 <GregorR> runhaskell -- -x hs -- /tmp/input.$$
03:14:43 <oerjan> that option is under "batch compilation", maybe it only applies to that
03:15:31 <oerjan> !haskell module Main where { main = putStr "Hello, world!\n" }
03:15:51 <GregorR> !haskell main = putStr "Hello, world!\n"
03:16:07 <GregorR> (I forced it to rename the file. Bloody annoying :P
03:17:02 <GregorR> It was easier than calling ghc and then running the resultant binary manually, although that also worked.
03:19:12 <oerjan> !haskell product [1..100]
03:19:14 <EgoBot> 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
03:19:37 <EgoBot> 788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000
03:19:43 <GregorR> !haskell product [1..1000]
03:19:58 <GregorR> Strugglin' a bout now, aren't ye Haskell! :P
03:21:03 <oerjan> !haskell length . show $ product [1..1000]
03:21:04 <EgoBot> 40238726007709377354370243392300398571937486421071463254379991042993851239862902059204420848696940480047998861019719605863166687299480855890132382966994459099742450408707375991882362772718873251977950595099527612087497546249704360141827809464649629105639388743788648733711918104582578364784997701247663288983595573543251318532395846307555740911426241747434934755342864657661166779739666882029120737914385371958824980812686783837455973174613608537953452422
03:21:28 * oerjan finds that unlikely to be his answer
03:22:00 <Asztal> strange how it would take so long, it finishes in 0.05s here
03:22:43 <GregorR> It has to set up the secure execution environment *shrugs*
03:22:44 <oerjan> well that was definitely mine
03:24:48 <pikhq> Is it normal for "Compiling Main" to take forever in ghci?
03:24:58 <pikhq> Or have I done something really screwy?
03:25:34 * oerjan doesn't actually know, still uses winhugs
03:25:48 <GregorR> Hahaha, a last bastion of HUGS :P
03:26:14 * pikhq suspects that mergesort was not necessarily the best choice of 'First Haskell program'. :P
03:26:17 <GregorR> (The original author of hugs endorses GHC in his Haskell class. True story, I was there, lawl :P )
03:26:38 <oerjan> whtspc also used it when i made the ferNANDo interpreter for him
03:27:01 <GregorR> What I meant was that winhugs is a last bastion of hugs.
03:27:01 <oerjan> builtin sort in ghc is mergesort, actually
03:27:37 <pikhq> Yes, but that's beside the point.
03:27:43 <oerjan> !haskell sort [-5, -4 .. 10]
03:27:49 <pikhq> ... This has been taking *quite* some time.
03:28:10 <GregorR> Well that certainly ought to have produced a result :P
03:28:19 <pikhq> [1 of 1] Compiling Main ( merge.hs, interpreted )
03:28:51 <oerjan> i expected a possible missing import, but not parse error...
03:29:02 <pikhq> If this were right, I would have implemented merge sort in 7 lines.
03:29:23 <pikhq> Which is, of course, purdy.
03:29:27 <oerjan> hm it worked fine in winhugs
03:30:04 <EgoBot> [-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10]
03:30:12 * pikhq suspects it's his merge algorithm that's giving troubles
03:30:39 <oerjan> !haskell [10, 9 .. -5]
03:30:40 <EgoBot> [10,9,8,7,6,5,4,3,2,1,0,-1,-2,-3,-4,-5]
03:30:49 <oerjan> !haskell sort [10, 9 .. -5]
03:31:24 <oerjan> !haskell length [10, 9 .. -5]
03:32:18 <oerjan> GregorR: i think when the expression gives an error, it tries the file, and then that gives a parse error
03:32:36 <GregorR> It does in fact do that, yes.
03:32:53 <GregorR> I didn't want to make it intelligently guess whether it's an expression or a full file.
03:33:16 <oerjan> !haskell import Data.List; main = print $ sort [10, 9 .. -5]
03:33:19 <EgoBot> [-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10]
03:34:01 <oerjan> !haskell main = print $ sort [10, 9 .. -5]
03:34:26 <oerjan> so it was the import error that was the actual cause
03:34:57 <pikhq> Note to self: infinite recursion is bad, mmkay?
03:35:48 <GregorR> Especially in a language in which tail recursion is rewritten as iteration, and so it'll never fail with a stack overflow or similar :P
03:35:49 <pikhq> For a merge algorithm operating on finite lists.
03:36:01 <oerjan> !haskell let l = 1:l in l
03:36:16 <GregorR> !haskell let 1 + 1 = 3 in 1 + 1
03:36:41 <Asztal> one might say that's corecursion
03:36:49 <oerjan> i guess that might not print anything because there is no newline
03:36:59 <GregorR> oerjan: It should give output with or without a newline.
03:37:09 <GregorR> !haskell putStr "Where's mah newline?"
03:37:18 <GregorR> .......... orrrrrr ... not?
03:37:33 <GregorR> Oh, in that case it won't, because it'll get killed with everything on the buffer.
03:38:08 <oerjan> !haskell take 1000 $ let l = 1:l in l
03:38:09 <EgoBot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
03:38:33 <Asztal> !haskell take 1000 $ fix error
03:38:47 <oerjan> i don't think fix is imported
03:39:04 <Asztal> !haskell import Control.Monad.Fix; main = print . take 1000 $ fix error
03:39:47 <oerjan> not immensely promising, that
03:39:49 <Asztal> oh, it wouldn't work anyway, because fix error doesn't actually yield a value
03:40:52 <oerjan> !haskell take 100 $ let fib = 1:1:zipWith (+) fib (tail fib) in fib
03:40:53 <EgoBot> [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049,12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,1548008755920,25
03:41:40 <GregorR> !haskell take 100 $ the cookie jar
03:41:49 <oerjan> !haskell import Control.Monad.Fix; main = print . take 1000 $ fix show
03:41:53 <EgoBot> "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
03:42:16 <GregorR> One-line Haskell is a force to be reckoned with :P
03:43:54 <oerjan> !haskell main = putStr s; print s where s = "main = putStr s; print s where s = "
03:44:25 <oerjan> !haskell main = putStr s >> print s where s = "main = putStr s >> print s where s = "
03:44:27 <EgoBot> main = putStr s >> print s where s = "main = putStr s >> print s where s = "
03:45:58 -!- Arrogant has quit ("Leaving").
03:48:40 * pikhq should not be having trouble getting half the length of a list. /me really shouldn't.
03:51:58 <GregorR> !haskell hl l = hl_p l + 1; hl_p l = hl l; main = print . hl [1, 2, 3, 4]
03:52:26 * pikhq figured that bit out
03:53:45 * oerjan suspect it was an Int vs. / problem
03:54:12 <GregorR> !haskell hl h:t = hl_p t + 1; hl_p h:t = hl t; main = print $ hl [1, 2, 3, 4]
03:54:27 <GregorR> Bleh, it's been too long since I've done Haskell X-D
03:55:37 <GregorR> !haskell hl (h:t) = hl_p t + 1; hl [] = 0; hl_p (h:t) = hl t; hl_p [] = 0; main = print $ hl [1, 2, 3, 4]
03:55:47 <GregorR> !haskell hl (h:t) = hl_p t + 1; hl [] = 0; hl_p (h:t) = hl t; hl_p [] = 0; main = print $ hl [1..1000]
03:57:36 <oerjan> !haskell foldr id 0 . zipWith (cycle [(+1), id]) $ [1..1000]
03:59:12 <oerjan> !haskell foldr id 0 . zipWith const (cycle [(+1), id]) $ [1..1000]
04:00:54 <oerjan> !haskell main = putStr . take 500 $ "BW" ++ cycle "AH"
04:00:57 <EgoBot> BWAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHA
04:07:19 * pikhq notes that Haskell is hard.
04:09:35 <oerjan> WARNING: BRAIN EXPLOSION IMMINENT
04:11:07 <oerjan> !haskell import Control.Monad; main = print . liftM product . replicateM 10 $ [-1,1]
04:12:37 <Warrigal> !haskell main = putStr s >> print s where s = "03:12 < Warrigal> !haskell main = putStr s >> print s where s = "
04:12:39 <EgoBot> [1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1
04:13:01 <oerjan> sometimes it looks like it waits for the next command
04:13:29 <Warrigal> !haskell main = putStrLn "u suck?"
04:13:36 -!- coppro has quit (Read error: 104 (Connection reset by peer)).
04:13:37 <oerjan> someone (Zzo38?) suggested calculating it with tensor product
04:13:54 <Warrigal> I should figure out what a tensor product is one of these days.
04:14:01 <Warrigal> Is it precisely what you jsut did?
04:14:04 <pikhq> oerjan: Brain explosion.
04:14:19 <oerjan> pikhq: anything i did? :D
04:14:30 <Warrigal> @haskell main = print (replicateM 10 [-1,1])
04:14:34 <Warrigal> !haskell main = print (replicateM 10 [-1,1])
04:15:01 <Warrigal> !haskell import Control.Monad; main = print (replicateM 10 [-1,1])
04:15:18 <EgoBot> [[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1,-1,-1,-1,1],[-1,-1,-1,-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,-1,-1,-1,1,1],[-1,-1,-1,-1,-1,-1,-1,1,-1,-1],[-1,-1,-1,-1,-1,-1,-1,1,-1,1],[-1,-1,-1,-1,-1,-1,-1,1,1,-1],[-1,-1,-1,-1,-1,-1,-1,1,1,1],[-1,-1,-1,-1,-1,-1,1,-1,-1,-1],[-1,-1,-1,-1,-1,-1,1,-1,-1,1],[-1,-1,-1,-1,-1,-1,1,-1,1,-1],[-1,-1,-1,-1,-1,-1,1,-1,1,1],[-1,-1,-1,-1,-1,-1,1,1,-1,-1],[-1,-1,-1,-1,-1,-1,1,1,-1,1],[-1,-1,-1,-1,-1,-1,1,1,1,-1],[-
04:16:07 <Warrigal> Oh, that's the boring straightforward way of doing it.
04:16:28 <Warrigal> I thought you were doing it the other way.
04:16:35 <pikhq> oerjan: The monad stuff did it.
04:16:47 <pikhq> I myself have yet to try anything brain-breaking.
04:16:52 <Warrigal> Which is probably the tensor product way.
04:16:54 <pikhq> I'm just finding merge sort hard.
04:17:11 <Warrigal> Something brain-breaking would be nice.
04:17:20 <oerjan> Warrigal: um this is essentially tensor product
04:17:30 * pikhq might need to paste that code for help
04:17:42 <oerjan> once you apply liftM product to it
04:18:00 <Warrigal> oerjan: what part is the tensor product part?
04:18:02 <oerjan> it's simply the tensor product of 10 copies of [-1,1]
04:19:37 <oerjan> it _is_ a little awkward to have to do imports explicitly
04:19:53 <oerjan> otoh it can run files from URLs
04:21:04 <Warrigal> It's currently copying patch 739 of 1860.
04:21:10 <GregorR> I could add a predetermined set of imports if you'd like.
04:21:28 <Warrigal> That sounds kind of inefficient, for C.
04:21:46 <GregorR> !c printf("The alternative sucks.\n");
04:21:47 <Warrigal> Anyway, now it's copying patch 1677 of 1860, so we should be done pretty quickly.
04:21:48 <EgoBot> The alternative sucks.
04:22:06 <Warrigal> Hey, look, now it's applying patch 703 of 1860.
04:22:35 <oerjan> Data.List and Control.Monad are sort of minimal for mind-boggling stuff
04:22:55 <oerjan> but of course the list is never-ending
04:24:31 <Warrigal> Delimited continuations are probably a good idea.
04:24:55 <oerjan> does lambdabot have that?
04:25:29 <oerjan> i don't recall that being a "standard" library
04:25:42 <Warrigal> lambdabot has lots of fancy stuff.
04:25:51 <Warrigal> Then again, I guess the standard library has lots of fancy stuff nowadays.
04:26:42 * Warrigal attempts to run GHCi on Slicehost.
04:26:49 -!- Warrigal has changed nick to DungeonMaster.
04:26:50 <oerjan> i guess the Haskell Platform is about to become the standard library
04:27:04 <GregorR> DungeonMaster: "Attempts"?
04:27:04 -!- DungeonMaster has changed nick to Warrigal.
04:27:08 <pikhq> DungeonMaster: It's not exactly inefficient to do includes in C.
04:27:29 <pikhq> All the includes do is hand the CPP some macros and C some function declarations.
04:27:35 <pikhq> (oh, and typedefs)
04:27:41 <Warrigal> Has that bug that makes it impossible to run GHCi on Slicehost been fixed yet, I wonder.
04:27:54 <pikhq> Really doesn't take more than half a second extra.
04:27:55 <oerjan> !haskell import System.Random; main = print =<< randomRIO (1,20)
04:28:31 <GregorR> !sh head -c 12 /dev/urandom 2>&1 | hexdump -C
04:28:31 <EgoBot> 00000000 2f 75 73 72 2f 62 69 6e 2f 68 65 61 64 3a 20 63 |/usr/bin/head: c|
04:28:45 <oerjan> !haskell import System.Random; main = print =<< randomRIO (1,20::Int)
04:29:35 <oerjan> i thought failing to default Random was a hugs-only bug :(
04:30:01 <Warrigal> Ticked #2063. Opened one year ago. Milestone: 6.12.1.
04:30:23 <Warrigal> Now to undo everything I did. Namely...
04:30:44 <Warrigal> Remove GHC, remove lamdabot, remove darcs.
04:32:44 <GregorR> !haskell putStr "I'm a little monad, short and stout. Here is my handle (arguments), here is my spoutput."
04:32:45 <EgoBot> I'm a little monad, short and stout. Here is my handle (arguments), here is my spoutput.
04:44:20 <Warrigal> What's the etymology of "spoutput"?
04:44:49 <HackEgo> spout (v.) \ c.1330, related to M.Du. spoiten "to spout," N.Fris. sptji "spout, squirt," Swed. sputa "to spout," and probably M.Du. spuwen "to spit" (see spew). Meaning "to talk, declaim" is recorded from 1612. The noun is first recorded 1392. It was the slang term for the lift in a pawnbroker's shop, up which articles were
04:44:52 <HackEgo> output (n.) \ 1839, from out and put. Till c.1880, a technical term in the iron and coal trade. The verb is attested from c.1300, originally "to expel;" meaning "to produce" is from 1858. \ \ monophonic \ of recordings, broadcasts, etc., "having only one output signal," 1958, coined to be an opposite of stereophonic (q.v.).
05:13:33 -!- coppro has joined.
05:17:11 <GregorR> Every time you log in, I think "crapppy's here!"
05:18:04 -!- sebbu has joined.
05:29:31 <coppro> thanks for the encouragement
05:30:09 <GregorR> Besides, "crappy" (and to a lesser degree, "crapppy") would be an IRC nick that /exudes/ confidence.
05:30:25 <GregorR> Like, "I'm so awesome I can call myself 'crappy' and still have awesome to spare"
05:34:34 -!- sebbu2 has quit (Read error: 110 (Connection timed out)).
05:37:18 <Warrigal> Like the time I used the nick DogFace.
05:37:46 <Warrigal> Someone said something about it. I don't remember what.
05:40:56 <oerjan> what, you mean that wasn't your real name?
05:49:09 <Warrigal> Gosh, I guess it is. I never realized that.
05:50:54 <GregorR> `addquote <oerjan> what, you mean that wasn't your real name? <Warrigal> Gosh, I guess it is. I never realized that.
05:50:55 <HackEgo> 10|<oerjan> what, you mean that wasn't your real name? <Warrigal> Gosh, I guess it is. I never realized that.
05:51:05 * GregorR wurves out-of-context statements.
06:00:50 <HackEgo> 10|<oerjan> what, you mean that wasn't your real name? <Warrigal> Gosh, I guess it is. I never realized that.
06:00:59 <HackEgo> 7|<AnMaster> that's where I got it <AnMaster> rocket launch facility gift shop
06:01:11 <HackEgo> 5|<Quas_NaArt> Hmmm... My fingers and tongue seem to be as quick as ever, but my lips have definitely weakened... <Quas_NaArt> More practice is in order.
06:07:18 -!- oerjan has quit ("leaving").
06:26:28 <Warrigal> That's not a pun, that's a euphemism used in its original sense.
06:31:01 <Warrigal> Yes, but that's not a pun, that's a euphemism used in its original sense.
06:31:17 <Warrigal> Though I guess it's also a pun.
06:32:11 <GregorR> If I say, "Hah, that Oedipus sure is a motherfucker!" that's not a pun.
06:32:18 <GregorR> (That's not really an example, I just found it funny)
06:33:30 <Warrigal> We should insult people by calling them Oedipus.
06:41:47 <Warrigal> Go create the universe the way Atum did!
06:49:11 <Warrigal> Regarding Atum: "As the original creator God, he made the world and everything in it by performing a certain self-pleasuring act. (Those of an innocent disposition can take this to mean he was chewing gum.)"
06:50:18 <Warrigal> Those mother-chewing idiots can go chew gum.
06:52:27 -!- Warrigal_ has joined.
06:53:01 * Warrigal disconnects in a sentient manner.
06:53:04 -!- Warrigal has quit ("leaving").
06:53:58 -!- coppro has quit (Read error: 110 (Connection timed out)).
07:13:30 -!- kar8nga has joined.
07:28:50 -!- immibis has joined.
07:39:33 -!- Warrigal_ has changed nick to Warrigal.
07:47:56 <Warrigal> "Turn your grave accent into a BACKSLASH!"
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:06:37 <immibis> warrie@lunch.normish.org???
08:08:47 <immibis> are you the rootnomic admin or something, that you get your own dns there?
08:13:32 -!- kar8nga has quit (Remote closed the connection).
08:15:37 <Warrigal> I own the domain name normish.org, which is registered with GoDaddy.
08:23:58 -!- immibis_ has joined.
08:24:20 <lament> godaddy is the worst thing ever
08:24:36 <lament> ..at least their email service is
08:31:21 <Warrigal> It does everything I want it to do.
08:33:28 -!- augur has joined.
08:40:50 -!- immibis has quit (Read error: 110 (Connection timed out)).
08:42:39 -!- pikhq_ has joined.
08:47:33 -!- pikhq has quit (Read error: 60 (Operation timed out)).
09:16:03 <augur> http://www.flickr.com/photos/passiveaggressive/3642661392/sizes/o/
09:20:02 -!- immibis_ has changed nick to immibis.
09:21:40 <immibis> i am trying to make an online mud (raw socket sort of thing) client at http://normish.org/home/immibis/mudclient/connect.php
09:21:49 <immibis> but it just randomly disconnects
09:22:31 <immibis> it uses a separate background process to communicate with the server (did i mention this was server-side + ajax) which is stopping for no apparent reason
09:22:55 <immibis> source code is at http://normish.org/home/immibis/mudclient/ if anyone wants to help me debug ir
09:49:57 -!- tombom has joined.
10:10:58 -!- Corun_ has joined.
10:25:47 -!- immibis has quit ("Some folks are wise, and some otherwise.").
10:31:27 -!- Corun_ has quit.
10:32:56 -!- MigoMipo has joined.
10:42:52 -!- augur has quit (Read error: 104 (Connection reset by peer)).
11:06:02 <AnMaster> ehird, damn you, you added that quote back still
12:12:26 -!- augur has joined.
12:12:37 <augur> part 5 is up: http://www.spinnoff.com/zbb/viewtopic.php?p=689452#689452
12:12:40 <augur> http://www.wellnowwhat.net/blog/?p=224
12:13:37 -!- deveah has joined.
12:38:30 -!- Sgeo has joined.
12:42:23 -!- bsmntbombgirl has quit (Read error: 110 (Connection timed out)).
12:45:17 -!- GreaseMonkey has quit ("HydraIRC -> http://www.hydrairc.org <- Nobody cares enough to cybersquat it").
12:53:41 -!- jix_ has quit (Read error: 113 (No route to host)).
13:01:16 -!- bsmntbombdood has joined.
13:47:50 <AnMaster> hm what would be a good name for an optimisation pass that transform code like this:
13:49:20 <AnMaster> that is, when value is used only once and then overwritten, remove the pointless store and propagate the calculation to the node that use the pointless store.
14:45:34 -!- upyr[emacs] has joined.
14:54:30 -!- augur has quit (Read error: 104 (Connection reset by peer)).
14:56:28 -!- augur has joined.
14:57:21 -!- FireyFly has joined.
15:10:40 <ehird> 18:50:18 * pikhq almost has a Haskell interpreter.
15:10:49 <ehird> 18:53:52 <pikhq> GHC takes a while to build.
15:10:51 <ehird> That's because you have to have GHC to compile GHC yo dawggggggggg.
15:10:52 <Warrigal> AnMaster: alpha transformation followed by beta transformation, I believe.
15:10:54 <ehird> Your distro probably downloads a binary to compile the sources.
15:11:04 <ehird> 18:58:04 <GregorR> Oh right, but that requires you have a main function. You can't just give it arbitrary code. I'd like to have it work either way, ideally.
15:11:09 <ehird> you just need an expr
15:11:12 <ehird> declarations can be 'foo where ...'
15:11:15 <ehird> or 'let ... in foo;
15:11:26 <Warrigal> AnMaster: alpha transformation turns it into this:
15:11:26 <ehird> !haskell putStrLn "you did disable IO right"
15:11:28 <EgoBot> you did disable IO right
15:11:49 <ehird> 18:58:39 <pikhq> Say, is there a haskell-mode?
15:11:51 <ehird> yes, there's two ones
15:11:52 <Warrigal> temp=255 + 255*p[8]; p[8]=temp; p[1]=0;
15:11:54 <ehird> a good one and a shit one
15:12:00 <Warrigal> And then beta transformation takes it the rest of the way.
15:12:03 <ehird> fyi, you have to press tab multiple times a lot
15:12:08 <ehird> since haskell indentation is ambiguous
15:12:23 <ehird> GregorR: well, you wouldn't due to root-ness
15:12:29 <ehird> GregorR: btw you don't need the decl style
15:12:37 <ehird> !haskell main=putStrLn "this is just more verbose than using where or let"
15:12:39 <EgoBot> this is just more verbose than using where or let
15:12:55 <ehird> let a=b;c=d in foo
15:13:04 <Warrigal> The first of those is the shortest.
15:13:08 <ehird> i guess it doesn't matter since you already have it
15:13:11 <ehird> Warrigal: well yeah, but whatever
15:13:21 <ehird> GregorR: ofc, "import" can only be done in the first style
15:13:22 <GregorR> Anyway, it's good to be able to just throw in full programs.
15:13:44 <GregorR> Where's my foo where import Shit;
15:13:47 <ehird> !haskell import System.IO.Unsafe; main = unsafePerformIO (putStrLn "im in ur type system, breaking it") `seq` return ()
15:13:49 <EgoBot> im in ur type system, breaking it
15:14:23 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
15:15:00 <ehird> !haskell import System.IO.Unsafe; import Data.IORef; lol :: a -> b; lol x = let bitch = unsafePerformIO (newIORef undefined) in unsafePerformIO (writeIORef bitch x >> readIORef bitch) main = print (lol main :: Int)
15:15:08 <ehird> !haskell import System.IO.Unsafe; import Data.IORef; lol :: a -> b; lol x = let bitch = unsafePerformIO (newIORef undefined) in unsafePerformIO (writeIORef bitch x >> readIORef bitch); main = print (lol main :: Int)
15:15:16 <ehird> !haskell import System.IO.Unsafe; import Data.IORef; lol :: a -> b; lol x = let bitch = unsafePerformIO (newIORef undefined) in unsafePerformIO (writeIORef bitch x >> readIORef bitch); main = print (lol main :: String)
15:15:27 <ehird> !haskell import System.IO.Unsafe; import Data.IORef; lol :: a -> b; lol x = let bitch = unsafePerformIO (newIORef undefined) in unsafePerformIO (writeIORef bitch x >> readIORef bitch); main = print (lol 3 :: String)
15:15:46 <ehird> !haskell import System.IO.Unsafe; import Data.IORef; lol :: a -> b; lol x = let bitch = unsafePerformIO (newIORef undefined) in unsafePerformIO (writeIORef bitch x >> readIORef bitch); main = print (lol 3 :: Either [String] [String])
15:15:59 <ehird> GregorR: That's "Left **Segmentation fault"
15:16:03 <ehird> You should make it print segfaults :P
15:16:17 <GregorR> You should make your mom print segfaults.
15:16:27 <ehird> I thought that was your job.
15:17:15 <ehird> 00:31:21 <Warrigal> It does everything I want it to do.
15:17:19 <ehird> also your argument for using Windows.
15:17:41 <GregorR> Also an argument for RealDolls.
15:19:55 <GregorR> AnMaster: Please don't revert over a week of changes just to settle a silly feud with ehird.
15:20:03 <ehird> don't encourage him :P
15:20:10 <GregorR> (OK, two days, whatever :P )
15:20:32 <AnMaster> GregorR, sure, but please make ehird respect your decision then.
15:20:58 <ehird> AnMaster: He reverted it including my quote, plus after you said that the first time he explicitly stated he wasn't giving any sort of "official opinion" on it.
15:21:04 <ehird> Nice appeal to authority, but seriously, just drop it.
15:21:18 <AnMaster> ehird, I suggest you drop it too then
15:21:40 <GregorR> I have no official opinion except that blood-feuds should be fought with minimal collateral damage to unrelated commits :P
15:25:31 -!- bsmntbombdood_ has joined.
15:26:48 -!- BeholdMyGlory has joined.
15:28:39 <ehird> 19:24:48 <pikhq> Is it normal for "Compiling Main" to take forever in ghci?
15:28:40 <ehird> 19:24:58 <pikhq> Or have I done something really screwy?
15:28:45 <ehird> Or your module is gigantic.
15:28:54 <AnMaster> GregorR, how is that done then?
15:29:14 <HackEgo> #!/bin/bash \ DB="sqlite3 quotes/quote.db" \ \ if [ "$1" ] \ then \ ARG=$1 \ ID=$((ARG+0)) \ if [ "$ID" = "$ARG" ] \ then \ $DB 'SELECT id,quote FROM quotes WHERE id='$ID \ else \ ARG=`echo "$ARG" | sed 's/'\''/'\'\''/g'` \ $DB 'SELECT id,quote FROM quotes WHERE quote LIKE
15:29:46 <ehird> AnMaster: Please drop it...
15:30:10 <AnMaster> ehird, but seriously, please stop adding it back, it isn't very funny even.
15:37:36 -!- jix has joined.
15:42:16 -!- deveah has quit ("MUHAHAHAH!!!1111").
15:46:51 -!- bsmntbombdood_ has quit (Read error: 110 (Connection timed out)).
15:47:29 -!- bsmntbombdood_ has joined.
15:52:37 -!- CESSMASTER has quit ("☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃☃").
16:01:07 -!- GregorR-L has joined.
16:02:06 <ehird> you know what's really stupid?
16:02:14 <ehird> no, not dongs. dongles.
16:02:18 -!- KingOfKarlsruhe has joined.
16:02:42 -!- KingOfKarlsruhe has left (?).
16:05:09 -!- FireyFly has quit ("Later").
16:23:58 -!- bsmntbombdood_ has quit (Read error: 110 (Connection timed out)).
16:31:36 -!- CESSMASTER has joined.
16:33:33 -!- pikhq_ has changed nick to pikhq.
16:33:35 -!- inurinternet has quit (Read error: 60 (Operation timed out)).
16:33:51 <pikhq> ehird: Yeah, it was really screwy.
16:34:05 <ehird> pikhq: i recommend grabbing a binary of ghc, painful as that may sound
16:34:14 <ehird> building it is a non-trivial affair, you might have messed up
16:34:16 <ehird> or your module was
16:34:27 <pikhq> ehird: Emerge built it.
16:34:39 <ehird> pikhq: what version is it
16:35:19 <ehird> pikhq: The latest version is *6.10.3*. 6.8.2 is years old and 6.10 has new language extensions and the like.
16:35:28 <ehird> If it's still on such an ancient version I'm not sure I trust whoever made that buildfile...
16:35:44 <ehird> i think 6.8.2 was released in like may 08
16:35:51 * pikhq wonders if there's a haskell overlay
16:37:03 <ehird> Right then, use that :-P
16:37:29 <Deewiant> When I last checked gentoo, 6.10.1 was out and 6.6.something was still in the main repo
16:37:56 <ehird> And Gentoo users complain about Debian dinos—ahem—stable!
16:37:59 <pikhq> 6.4.2 is still in the repo.
16:38:16 <ehird> 6.4 was released in March 2005.
16:38:20 <Deewiant> s/still in the main/still the latest in the main/
16:39:11 <ehird> pikhq: just checked; 6.8.2 was released December 2007. 6.8.3 was released in June 2008, so Gentoo has a version that's been out of date for a year and 7 months :P
16:39:23 <pikhq> Way to go, Gentoo, way to go.
16:39:38 <fizzie> If it were ion, they'd be sued already!
16:39:43 <Deewiant> ehird: Eh? It's been out of date since June 2008, so a year.
16:40:03 <ehird> Well, the version is a year and 7 months old.
16:40:09 <ehird> fizzie: lol@tuomov
16:40:50 <Deewiant> Many things are older than that but not at all out of date :-P
16:41:57 <Deewiant> Which reminds me for some reason, a vim bug I reported has apparently been fixed: http://www.mail-archive.com/vim_dev@googlegroups.com/msg05850.html
16:42:43 <ehird> A three line patch. Exciting
16:42:52 <Deewiant> "I'll look into it later." - Bram 2008-11-26
16:43:02 <ehird> cool, his signature is way giganticer than McQ limit
16:43:15 <ehird> and is as obnoxious about aid as the vim start screen :D
16:46:37 <Deewiant> Yes, one line saying "help me help" is obnoxious indeed... er, no it's not?
16:47:00 <ehird> Deewiant: i'm just irritated that every time I start up vim I get his soapbox
16:47:14 <ehird> also, it's 3 lines in vim
16:47:35 <ehird> "", "Help poor chi...", "type :help icc..."
16:47:42 <ehird> Deewiant: the extra newline wouldn't be there if it were removed
16:47:51 <ehird> yes it does, it's added space due to it
16:48:03 <Deewiant> It's around 10 lines and centered anyway
16:48:05 <ehird> Deewiant: but the line under the "VIM - Vi IMproved" doesn't
16:48:08 * Sgeo reported a bug in NetHack
16:48:13 <ehird> so we can only assume...
16:48:39 <Deewiant> ehird: Anyway, that is somewhat more annoying than the signature, yes.
16:49:52 -!- inurinternet has joined.
16:49:57 <Deewiant> I seem to recall that there's a way of disabling that startup screen but not what it is.
17:13:17 <ehird> [[please watch remarks like "only" and "obviously". they give an impression of close-mindedness.]]
17:13:32 <ehird> ↑ after I said you obviously won't find non-iphone app store apps in the app store :-P
17:13:47 -!- tombom has quit ("Peace and Protection 4.22.2").
17:15:19 <fizzie> Clearly it is better to use "clearly" instead.
17:15:41 <ehird> It stands to reason that $tautology.
17:15:54 <ehird> (to be fair, afterwards: [[oh -- you're right. i didn't read your "obvious" remark carefully]] )
17:27:48 <GregorR-L> It stands to reason that if 1 + 1 = 2, then 1 + 1 = 2.
17:29:19 <pikhq> It stands to reason that if succ 1 == 2, then succ 1 == 2.
17:30:01 <pikhq> (except in cases of languages with this pesky 'state' thing)
17:35:30 <ehird> pikhq: this is the smoothest haskell indoctrination i've ever witnessed
17:35:41 <ehird> are you sure you weren't a closet functional weenie to start with?
17:36:21 <pikhq> I, uh, am fond of math.
17:37:10 <ehird> pikhq: btw by the end of this you'll be unable to code in any other language without swearing every 5 minutes...
17:37:46 <pikhq> ehird: *Any* other? I'd hope I could at least code in languages that encourage functional programming.
17:38:05 <ehird> pikhq: But Haskell is the only widely-used lazy language...
17:38:15 <ehird> You might get by in OCaml until you try to do some operations on every integer ;-)
17:39:17 <pikhq> But, man. powers_of_two = map (2^) [1..]
17:39:36 <pikhq> I feel like I have achieved nirvana. :P
17:39:51 <ehird> pikhq: "powersOfTwo" is the convention, fwiw.
17:40:25 <ehird> pikhq: ThisIsCamelCase, thisIBelieveIsStudlyCaps
17:40:39 <ehird> StudlyCaps (or perhaps StUdLyCaPs, also known as StickyCaps) is a variation of CamelCase in which the individual letters in a word (or words) are capitalized and not capitalized, either at random or in some pattern.
17:41:00 <ehird> lowerCamelCase, I guess.
17:41:03 <pikhq> thisIsAVariantOfCamelCase.
17:41:03 -!- MizardX- has joined.
17:41:16 <Deewiant> UpperCamelCase, lowerCamelCase.
17:41:21 <ehird> you-are-now-thinking-of-lisp
17:41:47 <augur> deewiant, your UpperCamelCase is i thin called PascalCase
17:42:06 <ehird> that's a ridiculous nam
17:42:18 <augur> ehird: im just telling it like it is!
17:42:37 <comex> (just to complete the cycle)
17:44:09 * pikhq wonders why his mergesort is returning an empty list. Probably screwed something up.
17:44:16 <ehird> pikhq: show the source?
17:44:28 <comex> perhaps you asked it to sort an empty list
17:44:37 <pikhq> mergesort [10,9..1]
17:44:47 <ehird> The mergesort source.
17:44:54 <comex> pikhq: holy shit, that works
17:44:55 <pikhq> Yes. Pastebinning.
17:45:14 <comex> sometimes I love haskell
17:46:39 <pikhq> http://pastebin.ca/1471359
17:47:05 <ehird> Wow, that's way better code than I ever write as a new Haskeller.
17:47:11 -!- bsmntbombdood has joined.
17:47:26 <ehird> mergesort (x:xs) = let halfLength xs = truncate $ (fromIntegral . length) xs / 2
17:47:26 <ehird> (left, right) = splitAt (halfLength (x:xs)) (x:xs)
17:47:33 <ehird> pikhq: you only call halfLength once
17:47:49 <ehird> halfLength = truncate $ (fromIntegral . length) (x:xs) / 2
17:47:52 <Deewiant> pikhq: Your mergesorts will always return [].
17:48:06 <pikhq> Deewiant: Yes, that is the bug.
17:48:10 <Deewiant> Your mergesort returns either [], or mergesort foo `merge` mergesort bar
17:48:10 <ehird> pikhq: (btw you can do foo@(bar:baz) and foo=(bar:baz))
17:48:22 <augur> what other identifier naming conventions are there?
17:48:24 <Deewiant> And [] `merge` _ = _ `merge` [] = []
17:48:30 <Deewiant> So it can't return anything other than [].
17:48:38 -!- coppro has joined.
17:48:46 <pikhq> Mmm. Hooray, thinko.
17:48:48 -!- MizardX has quit (Read error: 145 (Connection timed out)).
17:48:54 <Deewiant> I have a recommended solution unless you want to figure it out yourself
17:49:01 <ehird> augur: ptsSystemsHungarian (pointer to struct :P) and scvsAppsHungarian (spelling convention)
17:49:02 -!- MizardX- has changed nick to MizardX.
17:49:05 <ehird> pikhq: yah, as a pattern match
17:49:16 <Deewiant> (Other stuff might still be broken but that should explain your issue)
17:49:29 <ehird> that's not really a case_convention though
17:49:32 <pikhq> Deewiant: Gimme a bit.
17:49:39 <ehird> augur: 'case convention' (for bizarro languages)
17:49:46 <augur> its a naming convention
17:49:52 <augur> if we allow method names, then we have like
17:50:14 <augur> thisIs:someAbsurdly:longMethod:nameLikeYouFind:inSmallTalk:andObjectiveC:
17:50:23 <ehird> that's a badly factored method.
17:50:35 <augur> actually its very often a very correctly factored method
17:50:52 <pikhq> Clearly, merge _ [] and merge [] _ are freaking wrong. ;)
17:51:00 <augur> they tend to be complex construct-like things
17:51:04 <augur> or complex query things
17:51:14 <augur> complex constructor-like things**
17:51:21 <Deewiant> pikhq: Heh, that's true too, but I don't think it'll solve the issue.
17:51:23 <pikhq> merge xs [] = xs and merge [] ys = ys ought to do it.
17:51:34 <pikhq> Hrm. Lemme test and see what I'm thinking of wrong now.
17:51:43 <Deewiant> Test first; maybe I'm wrong, although I don't think so.
17:52:00 <ehird> pikhq: Prove it correct in Coq!
17:52:43 <augur> for instace, you might have something like NSWindow's window:shouldDragDocumentWithEvent:from:withPasteboard:
17:52:55 <ehird> Cocoa isn't very good Smalltalk.
17:53:02 <augur> or dragImage:at:offset:event:pasteboard:source:slideBack:
17:53:03 <ehird> (If it were Smalltalk, that is.)
17:53:06 <pikhq> Can has stack overflow! Yay!
17:53:14 <augur> right, i know, but smalltalk has big method names too
17:54:05 <Deewiant> pikhq: The fix to that is the same as the fix I was thinking of earlier.
17:54:59 <augur> for instance, ehird, take the MenuMorph method add:subMenu:target:selector:argumentList
17:55:29 <augur> or addWithLabel:enablementSelector:target:selector:argumentList:
17:55:30 <comex> hey, I like that practice
17:55:40 <Deewiant> pikhq: What happens with lists of length 1?
17:55:49 <comex> [foo addWithLabel:lbl enabelementSelector:...
17:55:52 <comex> is a lot more clear than
17:55:59 <comex> foo.addWithLabel(lbl, es, tgt, sl, al)
17:56:08 <comex> as long as I have autocompletion so I don't have to actually type that shit out :p
17:56:25 <comex> sans autocompletion, give me the latter any time
17:56:27 <pikhq> Currently? ... Infinite recursion. Yay?
17:56:48 <augur> comex: yes, thats why its useful
17:56:53 <augur> its easier to remember
17:56:56 <augur> but its a lot more verbose
17:57:09 <pikhq> Because mergesort calls mergesort for all lists greater in size than 0.
17:57:30 <augur> but its also more proselike
17:57:38 <augur> and a lot of times it makes your code self-documenting
17:57:47 <ehird> pikhq: does it reduce the amount of work it has to do for such lists?
17:57:53 <ehird> if not, you're always going to loopinf.
17:58:00 <pikhq> Fixed with mergesort [x] = [x]
17:58:29 <pikhq> Now, I've just got it returning the reverse of the sorted list, because I screwed up the comparisons in merge.
17:58:37 <augur> // add a menu morph with a label, enablement selector, target, selector, and argumentlist
17:58:37 <augur> MenuMorph new addWithLabel: label enablementSelector: ls targer: targ selector: sel argumentList: arglist.
17:58:44 <augur> kind of redundant to have the comment!
17:59:04 <augur> pikhq: surely that is a bad basecase.
17:59:19 <ehird> why is that a bad base case
17:59:21 <Deewiant> mergesort [x] = [y] is much better, yes
17:59:31 <ehird> he has more than one base case...........
17:59:39 <augur> you only need the one!
17:59:42 <ehird> and | length xs (compare blah),
17:59:45 <ehird> scans the whole list
17:59:52 <Deewiant> mergesort x | null x || null (tail x) = x
17:59:59 <ehird> Deewiant: smells like lisp.
18:00:04 <AnMaster> for backend peephole optimiser, how insane is it to use regular expressions on the generated output to implement that :D
18:00:19 <Deewiant> ehird: mergesort x | liftM2 null (null.tail) x = x
18:00:22 <pikhq> Note: this is my first vaguely non-trivial Haskell.
18:00:43 <ehird> Deewiant: smells like bad haskell :)
18:00:52 <ehird> pikhq: it's very good
18:01:12 <pikhq> http://pastebin.ca/1471386 Final result.
18:01:37 <lament> haskell haskell haskell haskell haskell haskell haskell haskell haskell haskell haskell haskell HASKELL, HASKELL
18:01:40 <Deewiant> mergesort x | uncurry (||) . join (***) null . (id &&& tail) $ x = x
18:01:45 <lament> A HASKELL!!! A HASKELL!!
18:02:16 <ehird> 18:02 ehird: @type div
18:02:16 <ehird> 18:02 lambdabot: forall a. (Integral a) => a -> a -> a
18:02:20 <Deewiant> mergesort x | (id &&& tail) >>> join (***) null >>> uncurry (||) $ x = x
18:02:21 <ehird> pikhq: truncate $ (fromIntegral . length) xs / 2
18:02:41 <lament> Deewiant: honestly what the fuck. that's beautiful. does it work?
18:03:08 <ehird> pikhq: additionally, your "halfLength xs = ..." should become "halfLength = length (x:xs) `div` 2" since you only use it once
18:03:11 <Deewiant> lament: Of course it does. :-P
18:03:14 <ehird> apart from that, good code
18:03:34 <ehird> pikhq: although I'd do oxs@(x:xs) and oys@(y:ys) everywhere
18:03:39 <ehird> since you do a lot of (x:xs) stuff
18:03:41 <pikhq> Certainly not bad for your first vaguely non-trivial Haskell.
18:03:53 -!- bsmntbombdood has quit (Connection timed out).
18:03:54 <ehird> just some general stylistic suggestions
18:04:11 <Deewiant> My first vaguely non-trivial Haskell was essentially an imperative program
18:04:28 <ehird> ("cabal install hlint"; if you don't have cabal(1), install your distro's cabal-install package)
18:04:40 <ehird> or get hlint from your package manager if it offers it
18:05:10 <lament> my every non-trivial haskell program (well, both of them) is essentially an imperative program :(
18:05:32 <ehird> i highly suspect pikhq of knowing haskell for years
18:05:35 <lament> well no, i have a chord parser that's just parsec stuff
18:05:58 <Deewiant> Mine uses clever types like type Result = (Mapping, String, (Int, Int, Int, Bool, Bool), String) -- (program, title, (GOODs, BADs, UNDEFs, END?, N/A?), output)
18:06:23 <Deewiant> Unsurprisingly, it devotes 18 lines to defining fst,snd,trd,frth,ffth for tuples up to size 5
18:07:10 <Deewiant> ("Program", wrapThCol . htmlEscape . fst . fst . fst3),
18:07:18 <Deewiant> Beats me what fst . fst . fst3 means here.
18:07:18 * ehird kills Deewiant with a fork
18:07:43 <Deewiant> case ((snd $ fst3 p) `elemIndex` (map (snd.fst4.snd) fr)) of
18:08:14 <ehird> pikhq: Yeah, eeeew.
18:08:26 <pikhq> ehird: Good call with oxs@(x:xs). That's nice.
18:08:38 <Deewiant> Hey, this program is important: it parses my custom-type files which have the mycology comparison data
18:08:54 <ehird> pikhq: I'm not sure "oxs" is the best name, but I couldn't think of anything better :P
18:08:54 <Deewiant> Incidentally, it could also use a rewrite, but that's besides the point
18:09:13 <Deewiant> buildTable' _ _ _ _ [] _ [] = "</tbody>"
18:09:23 <Deewiant> There's some kind of Zen to this, I'm sure.
18:09:36 <ehird> Man, pastebin that program, pronto.
18:09:38 <Deewiant> I've only had to fix one bug in it, I think.
18:09:38 <pikhq> ehird: Well, it's certainly cleaner than using (x:xs) everywhere.
18:10:53 <pikhq> Now if only I could remember how ti install Emacs Lisp packages so I could have Haskell mode.
18:11:01 * pikhq gets out his dead-tree manual
18:11:14 <Deewiant> http://deewiant.pastebin.com/f3306916
18:11:41 <ehird> pikhq: Package manager?
18:11:47 <ehird> pikhq: BTW, you want the "haskell-indentation" mode too.
18:11:54 <ehird> Also inferior-haskell, if you're into that sort of thing.
18:11:59 <AnMaster> Deewiant, that green background thingy for strings. Unusual.
18:12:35 <ehird> Deewiant: jeez that program sucks
18:12:45 <ehird> (jeez that syntax highlighting sucks)
18:12:56 <Deewiant> That program rocks, it does exactly what it should.
18:13:13 <lament> i was completely unable to install lexah :(
18:13:32 <ehird> lament: gtk + os x is like ... two things that don't go together without a lot of pain.
18:13:41 <ehird> like... like gtk and os x.
18:13:55 <lament> i'm stuck doing haskell in vim
18:13:58 <AnMaster> Deewiant, nice definition of rocks
18:14:01 <ehird> i haven't used leksah but I don't like how it changes 'beta' to the greek symbol and thus encourages you to use it
18:14:04 <lament> which only sort of works
18:14:09 <ehird> (it also does "gamma")
18:14:13 <ehird> since that's not typically used in haskell.
18:14:22 <ehird> also i don't really like IDEs
18:14:30 <AnMaster> Deewiant, it isn't clean or such though.
18:14:43 <ehird> if textmate was open source, worked on more stuff, and had a port of haskell-indentation.el, I'd be all over it
18:14:59 <Deewiant> "if textmate was emacs I'd be all over it"
18:14:59 <ehird> atm i just use it anyway and manually indent haskell since it's the easiest
18:15:06 <pikhq> Sweet. Haskell mode FTW.
18:15:09 <ehird> Deewiant: no, emacs is mostly shit :P
18:15:15 <ehird> i want a few specific things, i.e.
18:15:19 <ehird> being open source — not emacs-specific
18:15:27 <ehird> worked on more stuff — nor this
18:15:34 <ehird> a port of haskell-indentation.el — nor this.
18:15:41 <AnMaster> but the total result is emacs :P
18:15:42 <ehird> pikhq: yah, it is nice.
18:15:54 <ehird> AnMaster: for definitions of emacs that are willfully ignorant and ignore a huge portion of emacs.
18:16:06 <lament> emacs is pretty horrible
18:16:12 <AnMaster> ehird, I thought those were included in "worked on more stuff"?
18:16:25 <AnMaster> stuff includes irc for example clearly
18:16:26 <lament> also haskell is different enough from everything else that it easily deserves a dedicated editor
18:16:41 <ehird> AnMaster: stuff = platforms.
18:17:00 <AnMaster> ehird, that wasn't clear from the context. Could have been "more file formats" or such
18:17:07 <ehird> lament: meh; the only hard part that you can't do with a general language mode is indentation
18:17:23 <ehird> AnMaster: you're the only person who could see it as ambiguous..
18:17:43 <Deewiant> ehird: I thought it meant file formats.
18:17:43 <AnMaster> ehird, err, have you asked everyone else in the channel?
18:17:54 <Deewiant> It's the thing I associate emacs with.
18:17:54 <ehird> ok, everyone who's a dirty foreigner
18:17:56 * pikhq notes that Gentoo's haskell mode package installs haskell-mode, haskell-indent-mode, and inferior-haskell.
18:18:07 <ehird> pikhq: Haskell-indent-mode?
18:18:08 <Deewiant> ehird: Right, everybody native understands "stuff == OSs" :-)
18:18:17 <ehird> maybe that's haskell-indentation's mode name
18:18:29 <lament> ehird: indentation, prettification (like leksah does), automatic documentation, "go to definition", "find usages", refactoring, interface with hoogle, automatic completion
18:18:33 <pikhq> If it's a mode, it's a minor mode.
18:18:38 <ehird> you do know how inferior-modes work right, pikhq? :P
18:18:41 <pikhq> Yeah, it's a minor mode.
18:18:46 <ehird> pikhq: it's automatic
18:18:52 <ehird> it hooks into haskell-mode
18:18:58 <lament> ehird: listing of stuff in a module
18:19:12 <pikhq> Ooookay... That doesn't exactly come up much in Emacs, now does it? :P
18:19:22 <lament> ehird: hooks with GHC obviously
18:19:26 -!- augur has quit (Read error: 104 (Connection reset by peer)).
18:19:30 <lament> ehird: including debugging and profiling
18:19:35 -!- augur has joined.
18:19:44 <ehird> lament: indentation — the only hard part; prettification — leksah just does some alpha/gamma shit and :: and ->, meh; automatic documentation — meh; "go to definition" — should go in the language mode; "find usages" — ditto, editors should support this stuff; refactoring — meh, make a plugin; hoogle — meh; completion — language mode
18:19:48 <ehird> listing — language mode
18:20:26 <lament> prettification is quite hard, i suspect
18:20:38 <ehird> lament: yes, but it isn't all that valuable
18:20:41 <lament> ehird: yes, but your mehs are unjustified
18:20:46 <Deewiant> !haskell main = print (repeat 5 "meh")
18:20:46 <ehird> also, leksah just does a few boring adjustments
18:20:54 <ehird> !haskell repeat 5 "meh"
18:20:57 <lament> i'm not saying how awesome leksah is, i've never even used it
18:20:58 <ehird> lament: so your mom
18:21:01 <ehird> GregorR-L: hey it broked.
18:21:13 <ehird> (note: its cocoa ui is unusable)
18:21:21 <lament> ehird: i suspect i'm going to hate anything that has a vim mode and an emacs mode.
18:21:21 <ehird> !haskell repeat 5 "GregorR-L it is broke"
18:21:36 <ehird> lament: ok, if you prefer to spend your time arguing on irc :P
18:21:50 <Deewiant> !haskell print (repeat 5 "meh")
18:21:58 <ehird> Deewiant: no Data.List
18:22:00 <ehird> i think is the issue
18:22:05 <ehird> GregorR-L: it used to print out the expression automatically if you didn't yourself
18:22:09 <ehird> ↑ this used to work
18:22:14 <Deewiant> !haskell print (replicate 5 "meh")
18:22:15 <EgoBot> ["meh","meh","meh","meh","meh"]
18:22:19 <ehird> there's no such thing as repeat
18:22:26 <ehird> GregorR-L: make it give us the error messages then :P
18:22:28 <ehird> Deewiant: well right
18:22:37 <ehird> !haskell repeat "lol"
18:22:55 <ehird> egobot sucks due to not having rate limiting and line cutoff and shit; can we get lambdabot in here?
18:22:57 <GregorR-L> ehird: Make it give your mom the error messages.
18:22:58 <ehird> who owns lambdabot these days, Cale?
18:23:03 <lament> !haskell sequenceM_ (repeat (print "lol"))
18:23:07 <Deewiant> ehird: Don't respond to the DCC...
18:23:35 <Deewiant> Configure your client properly, or switch to another.
18:23:57 <ehird> anyway i don't want a bunch of shitty dcc windows :P
18:24:01 <lament> !haskell sequence_ (repeat (print "lol"))
18:24:19 <ehird> Deewiant: tabs. in my irc client.
18:24:30 <Deewiant> ehird: And what does this have to do with anything?
18:24:59 <ehird> i don't want to switch to a dcc-doing client because i don't think it's a reasonable way for EgoBot to do things anyway
18:25:02 <Deewiant> Is your current situation not a billion shitty DCC windows
18:25:19 <ehird> no, my current situation is nothing because my client doesn't support dcc.
18:25:20 <GregorR-L> ehird complains endlessly about EgoBot DCC'ing.
18:25:36 <GregorR-L> I'm playing the world's smallest violin for you, ehird.
18:25:44 -!- ChanServ has set channel mode: +o lament.
18:25:45 <Deewiant> Ah, I thought you were complaining about how you get DCC spammed without cutoff and shit
18:25:56 -!- lament has set channel mode: -o lament.
18:26:02 <ehird> GregorR-L: what about the world's smallest pianist?
18:26:07 <ehird> lament: THREATENING OPS OF DOOM
18:26:27 <lament> threatening, yet completely impotent
18:26:39 <ehird> quick everyone, be on your best behaviour for lambdabot coming in here.
18:26:47 -!- gwern has joined.
18:27:04 * ehird looks professional.
18:27:05 -!- lambdabot has joined.
18:27:22 <Deewiant> Do we really need to bring "the" lambdabot here?
18:27:27 <lament> a parade, in honour of lambdabot!!
18:27:31 <lambdabot> ["yes","yes","yes","yes","yes","yes","yes","yes","yes","yes","yes","yes","y...
18:27:34 <Deewiant> As opposed to GregorR or somebody just running their own
18:27:38 <lament> @vixen do we really need you here?
18:27:42 <ehird> Deewiant: why bother?
18:27:44 <lament> @vixen or would you rather go away?
18:27:46 <ehird> this is simpler :-P
18:27:51 <Deewiant> This is the kind of place where people try to DOS bots and break them
18:28:01 <Deewiant> lambdabot is broken enough as-is :-P
18:28:04 <lament> @vixen baby, wanna get DOSed?
18:28:14 <lament> @vixen what about hot sex?
18:28:15 <ehird> lambdabot's in too many channels, we're too responsible (← wishful thinking) ;-)
18:28:18 <Deewiant> For instance, I don't know if it has protection against bot-loops
18:28:20 <ehird> lament: get a room
18:28:26 <Deewiant> In fact, I seem to recall it doesn't
18:28:28 <ehird> Deewiant: it doesn't do any commands
18:28:29 <lament> @vixen do you have protection?
18:28:32 <ehird> it prefixes output with a space
18:28:44 <ehird> so unless your bot's prefix is " "
18:28:44 <Deewiant> That used to be circumventable
18:28:44 <AnMaster> <ehird> no, my current situation is nothing because my client doesn't support dcc. <-- what a stupid client.
18:28:46 <lament> loops are an important point
18:28:53 <lament> we can pretty much guarantee people will try to make them
18:28:58 <pikhq> > let s x y z = x z (y z); k = x y = x; i = s k k;in i [1..10]
18:28:59 <lambdabot> <no location info>: parse error on input `='
18:29:01 -!- labo has joined.
18:29:22 <lambdabot> lexical error in string/character literal at chara...
18:29:24 <pikhq> That would be fail.
18:29:29 <pikhq> > let s x y z = x z (y z); k x y = x; i = s k k;in i [1..10]
18:29:35 <ehird> lament: ais523 and me are the most common loopers and ais is probably too responsible to botloop lambdabot, and i'm too lazy :)
18:29:42 <pikhq> Thas more like it.
18:29:50 <ehird> Well, it's good to see a regular day in #esoteric is progressing.
18:30:03 -!- lament has set topic: David slowed his pace slightly as his ears, which had been tingling painfully, burst forth off of his head, leaving two bleeding gashes. "Ouch," he sputtered, pulling hair wet with blood off of his scalp. But there was no time to bandage the wound, as he quickly regained his running stride as the pirate alligator bear mutants waddled after him. | http://tunes.org/~nef/logs/esoteric/?C=N;O=D | Don't botloop lambdabot..
18:30:04 <Deewiant> pikhq: s = ap, k = const, i = id
18:30:16 <lambdabot> forall (m :: * -> *) a b. (Monad m) => m (a -> b) -> m a -> m b
18:30:24 * ehird scares pikhq with the scary type signature.
18:30:40 <pikhq> Deewiant: Doesn't surprise me, but I just want SKI for a bit.
18:30:47 -!- lament has set topic: David slowed his pace slightly as his ears, which had been tingling painfully, burst forth off of his head, leaving two bleeding gashes. "Ouch," he sputtered, pulling hair wet with blood off of his scalp. But there was no time to bandage the wound, as he quickly regained his running stride as the pirate alligator bear mutants waddled after him. | http://tunes.org/~nef/logs/esoteric/?C=N;O=D | Be nice to lambdabot!.
18:30:47 <pikhq> ehird: The monads! The monads!
18:31:04 <pikhq> I am a pitiful Haskell noob!
18:31:11 <lambdabot> forall (m :: * -> *) a b (m1 :: * -> *) a1 b1 c'. (Monad m, Monad m1) => (((m (a -> b), m1 (m1 a1)) -> b1) -> c') -> ((m (a -> b), m1 (m1 a1)) -> b1) -> ((m (a -> b), m1 (m1 a1)) -> (m a -> m b, m1
18:31:23 <lambdabot> Source not found. That's something I cannot allow to happen.
18:31:27 <Deewiant> pikhq: Sure, just saying that they're all available under standard names.
18:31:30 <ehird> whcih was I thinking about.
18:32:04 <pikhq> Cleaned up my merge sort, BTW>
18:32:05 <pikhq> http://pastebin.ca/1471435\
18:32:10 <pikhq> http://pastebin.ca/1471435 , even.
18:32:28 <ehird> pikhq: that's pretty much how I'd write it
18:32:30 <Deewiant> Still shadows oxs, x, xs. Better, though.
18:32:33 <lambdabot> YHC says: There is currently no debugging system available. Please write correct programs.
18:32:37 <ehird> pikhq: | x < y, | x >= y
18:32:40 <lambdabot> ghc says: PArse error (possibly incorrect indentation)
18:32:42 <ehird> | x < y, | otherwise
18:32:44 <ehird> (otherwise = True :-))
18:32:46 <lambdabot> ghc says: Use -fglasgow-exts to allow multi-parameter classes
18:32:52 <lambdabot> ghc says: PArse error (possibly incorrect indentation)
18:32:57 <lambdabot> ghc says: jump island out of range
18:32:58 <ehird> Deewiant: is shadowing those really a big deal?
18:32:59 <pikhq> ehird: True, true. One last C-ism. :P
18:33:02 <ehird> merge is separate from the main mergesort body
18:33:07 <ehird> pikhq: wouldn't you say "else" in C?
18:33:13 <ehird> not if (x < y) { ... } else if (x >= y) { ... }
18:33:15 <gwern> isn't that merge definition a line too long?
18:33:19 <Deewiant> ehird: Since they have the same type, if you change the inner to z:zs you might still reference x:xs accidentally
18:33:31 <ehird> Deewiant: that's true.
18:33:36 <gwern> merge xs [] = xs; merge [] ys = ys == merge xs ys = xs ++ ys ?
18:33:38 <Deewiant> Or you want to reference the outer, or something
18:33:44 <pikhq> gwern: My first Haskell, so... Maybe.
18:34:10 <ehird> gwern: "erge [] ys = ys == merge xs "
18:34:20 <gwern> I mean, those can only differ if there are 2 full-list args, but you've defined no case for that
18:34:23 <Deewiant> ehird: mapM, forM, filterM, foldM, replicateM, liftM, off the top of my head
18:35:01 <lambdabot> forall a (m :: * -> *). (MonadFix m) => (a -> m a) -> m a
18:35:08 <gwern> so you could put the third merge clause first, and then fall back on merge a b = a++b
18:35:18 <ehird> :t take 100 (iterate Just Nothing)
18:35:19 <lambdabot> Occurs check: cannot construct the infinite type: a = Maybe a
18:35:23 <Deewiant> I'm somewhat against putting base cases last
18:35:36 <ehird> gwern: "erge [] ys = ys == merge xs"
18:35:38 <ehird> does that make any sense to you?
18:35:43 <ehird> merge doesn't return a boolean.
18:35:53 <ehird> pikhq: shushest thou
18:36:03 <gwern> ehird: I was being informal
18:36:04 <lambdabot> forall (m :: * -> *) a b. (Monad m) => m a -> (a -> m b) -> m b
18:36:20 <lambdabot> forall a (m :: * -> *) b. (Monad m) => (a -> m b) -> m a -> m b
18:36:28 <lambdabot> forall b a (m :: * -> *) b1. (Monad m) => (a -> m b1) -> (m b1 -> m a -> b) -> m a -> b
18:36:29 <Deewiant> ehird: He meant that 'merge xs [] = xs; merge [] ys = ys' == 'merge xs ys = xs ++ ys'
18:36:42 <ehird> yeah, that works if you put the base case last
18:36:45 <ehird> but is imo a bit confusing
18:36:57 <lambdabot> forall a. (Ord (a -> Bool), Ord a) => a -> (a -> Bool) -> Bool
18:37:06 * ehird attempts to find a use for (>>=).(=<<)
18:37:11 <lament> what kind of type is (m b1 -> m a -> b)
18:37:21 <ehird> unless it involves unsafePerformIO ;-)
18:37:34 -!- augur has quit (Read error: 104 (Connection reset by peer)).
18:37:41 -!- augur has joined.
18:37:44 <Deewiant> ?ty const.const 1 -- this kind of type
18:37:45 <lambdabot> forall b b1 a. (Num b) => a -> b1 -> b
18:38:08 <Deewiant> ?djinn (a -> mb1) -> (mb1 -> ma -> b) -> ma -> b
18:38:40 <ehird> !djinn does lambdabot listen on !s?
18:38:46 <coppro> Have I ever mentioned that Haskell scares me?
18:38:47 <ehird> no EgoBot conflict then :P
18:38:50 <lambdabot> fd:7: hClose: resource vanished (Broken pipe)
18:38:54 <ehird> cool, still broken
18:39:05 <ehird> it's warm and fluffy!
18:39:22 <coppro> also got more weird syntax than shafuck
18:39:57 <ehird> haskell's syntax is perfectly regular
18:39:57 <gwern> weird? haskell syntax is lovely
18:40:03 <ehird> it just has a lot of operators bolted on ;-)
18:40:11 <ehird> (ok, it's not regular in the formal sense; shut up)
18:40:23 <Deewiant> I can understand why somebody might not see (>>=).(=<<) as lovely.
18:40:24 <gwern> although I sometimes wonder if $ doesn't cause more problems than it solves
18:40:56 <pikhq> Having just started learning Haskell last night, Haskell seems to allow for some really lovely and elegant code.
18:41:16 <pikhq> (oh, and Haskell is the first functional language I've really bothered trying to learn)
18:41:17 <labo> @unpl (>>=).(=<<
18:41:19 <labo> @unpl (>>=).(=<<)
18:41:24 <Deewiant> And it allows for really horrible and unreadable code too - a true general-purpose language!
18:41:26 <coppro> also arcane and not even remotely comprehensible to anyone not familiar with it
18:41:43 <coppro> Deewiant: sounds like C++!
18:41:50 <ehird> that applies to all languages, coppro
18:41:53 <ehird> how is haskell syntax arcane?
18:41:54 <pikhq> Except less awful.
18:41:54 <Deewiant> I don't consider being comprehensible to someone not familiar with a language an inherent merit of the language
18:42:05 <ehird> huh http://esolangs.org/wiki/ redirects to voxelperfect but http://esolangs.org/wiki/Main_Page doesn't
18:42:28 <gwern> ehird: precedence and parsing can be confusing, especially when multiple things get involved like ., $, [], and function application
18:42:46 -!- ehird has set topic: David slowed his pace slightly as his ears, logging the channel to http://tunes.org/~nef/logs/esoteric/?C=N;O=D, noted that lambdabot was in their midst and decreed that everyone shall be nice to it. They also noted that the wiki is at http://esolangs.org/wiki/..
18:42:50 <Deewiant> ehird: Some spam today, in http://esolangs.org/wiki/Special:Recentchanges
18:43:01 <ehird> i'm just wondering about the odd redirection
18:43:15 <gwern> I will say that haskell seems to get strings and chars right; I was flummoxed when I was learning scheme and saw characters weren't 'a', but #\a or something weird like that
18:43:45 <ehird> because ' is quote.
18:44:09 -!- kar8nga has joined.
18:44:16 <ehird> Deewiant: too ambiguous for scheme's tastes.
18:44:22 <gwern> ehird: yeah, I eventually realized that, but still
18:46:24 <pikhq> ehird: Anyways, I think that Haskell will only break my brain when I get to monads...
18:46:36 <ehird> monads just clicked with me first time
18:46:50 <pikhq> Hmm. Well, we'll see when I get there.
18:47:12 <ehird> i just used, like, IO and State with do notation, then I saw their definition and how you can use the operators to write IO/State stuff, then I saw the definition of the list monad and worked out how it worked and /shrug
18:48:50 <pikhq> Anyways, so far, just the whole 'purely functional' thing seems to... Make sense.
18:49:00 -!- bsmntbombdood has joined.
18:49:06 <pikhq> Was not expecting that.
18:49:13 -!- deveah has joined.
18:49:32 <ehird> purely functional languages, i think, are obvious from strong type systems
18:49:45 <coppro> Purely functional can be good
18:49:45 <ehird> as side-effecting vs not is another type distinction to be made
18:49:52 <ehird> and you don't actually need impurity to do side-effects.
18:50:03 <ehird> coppro: OO-only is never good.
18:50:39 <coppro> I think 'never' is too strong
18:50:46 <ehird> Java's a bad example because it's so terrible besides.
18:51:18 <coppro> It also depends to what extent you consider something to be OO - do anonymous delegates count as OO?
18:51:54 <coppro> heck, even purely imperative programming is sometimes most appropriate for a task
18:52:17 <ehird> @faq Can Haskell do purely imperative programs?
18:52:17 <lambdabot> The answer is: Yes! Haskell can do that.
18:52:53 <Deewiant> ehird: The list monad still serves mostly to confuse me :-)
18:53:16 <ehird> Deewiant: It's just "amb".
18:53:36 <Deewiant> Oh, it's just id. No, wait, it's not. :-P
18:53:52 -!- bsmntbombdood has quit (Read error: 60 (Operation timed out)).
18:54:35 <ehird> Deewiant: It's id in the list monad:
18:54:45 <Deewiant> I just don't think that anything nontrivial with it is very intuitive.
18:54:59 <Deewiant> filterM (const [True,False]) [1,2,3] -- quick, what does this do?
18:55:10 <ehird> OK, that's confusing.
18:55:35 <ehird> > do a <- [1,2,3]; b <- [4,5,6]; when (x*y /= 8) []; return (a,b)
18:55:46 <ehird> Whatever, it used to work :P
18:55:58 <ehird> Anyway, the list monad can be useful.
18:56:13 <ehird> Plus, it IS a monad, so omitting the instance is just silly.
18:56:14 <gwern> for generating permutations, for example
18:56:29 <gwern> (useful in my scripts)
18:57:14 -!- inurinternet has quit (Read error: 60 (Operation timed out)).
18:57:14 <ehird> > (map f [x,y],foldr (f.g) [1,2,3])
18:57:19 <ehird> Oh, not that rubbish.
18:57:27 <ehird> > do a <- [1,2,3]; b <- [4,5,6]; when (a*b /= 8) []; return (a,b)
18:58:04 <Deewiant> > (map f [x,y] :: [Expr],foldr f 0 [1,2,3] :: Expr)
18:59:06 <ehird> > (map f [x,y],foldr (f.g) 0 [1,2,3])
18:59:26 <Deewiant> ?ty map f [x,y] -- this is why
18:59:27 <lambdabot> forall b. (SimpleReflect.FromExpr b) => [b]
19:02:31 <ehird> GregorR-L: Hey, you should add a !mathematica.
19:02:38 <ehird> Although that'd require you to have a Mathematica license.
19:02:42 <coppro> doesn't `wolfram do that?
19:02:50 <ehird> Octave is not mathematica :P
19:02:55 <ehird> coppro: no, `wolfram is Alpha
19:03:05 <coppro> yes, but that runs things through mathmatica
19:03:05 <Deewiant> Alpha is close enough for most purposes.
19:03:33 <GregorR-L> Oh, that's MATLAB-y, not MATHEMATICA-y, forgot :P
19:03:54 <ehird> you can't even define functions and then use them in an alpha line
19:04:09 <ehird> and no, you're simply wrong; i use mathematica all the time for shit alpha would splutter on
19:04:21 <ehird> Deewiant: for definitions of most purposes limited to "what I use"? ic
19:04:36 <Deewiant> ehird: Of course, what other purposes are there
19:04:50 <Deewiant> On a more serious note, are those 'all the time' things oneliners?
19:06:39 <pikhq> Bah. Maxima is awesome and you know it. :P
19:07:18 <ehird> mathematica's syntax is a lot nicer
19:07:24 <ehird> and it has a bigger stdlib
19:13:29 * ehird writes MathematicaBot.
19:14:15 <ehird> I hope mathematica can't write files. Crap, it can.
19:16:37 <ehird> GregorR-L: does it work on Darwin?
19:16:54 <ehird> gwern: man, I have no idea how many thousands of dependencies Mathematica has
19:17:01 <GregorR-L> In fact, I know it doesn't, as it includes a glibc patch.
19:22:13 <pikhq> I hereby resolve to never use Mathematica.
19:22:28 <ehird> He's talking about.
19:22:45 <ehird> pikhq: Oops, you can't retract vows :-P
19:22:57 <ehird> (Well, plash, but pola-run is part of plash)
19:23:07 -!- gwern has left (?).
19:23:10 <pikhq> I'll just have to scam Agora's contract rules, won't I?
19:23:24 <ehird> With Haskell. (Somehow.)
19:23:29 <ehird> i wanna write a mathematica replacement in haskell sometime
19:26:46 -!- kar8nga has quit (Remote closed the connection).
19:30:38 -!- inurinternet has joined.
19:32:57 <ehird> Challenge: communicate with only verbs.
19:33:26 <lament> in russian there's a phrase consisting of six infinitives in a row
19:33:59 <lament> собраться встать пойти купить выпить
19:34:24 <lament> "to decide to get up to go to buy (something) to drink"
19:34:32 <ehird> "verbing weirds communicating"
19:35:21 <CESSMASTER> of course it's about drinking in the morning
19:36:31 <lament> get up in the sense of stop sitting
19:40:23 <ehird> pikhq: i was about to be offended for a second
19:41:21 <ehird> lol@guy in #haskell asking for C# help
19:47:51 <ehird> "19:47 jmcarthur_work: Baughn, if the universe is infinitely large, there is a 100% probability of exactly our portion of the universe existing somewhere"
19:48:07 <ehird> "19:47 jmcarthur_work: assuming it is random, i mean"
19:48:10 <ehird> Stop getting angry
19:48:17 <GregorR-L> There is a 100% probability of exactly our portion of the universe existing somewhere.
19:49:01 <GregorR-L> And also, "random" isn't /quite/ sufficient, it could be random over a range not including us.
19:49:33 <GregorR-L> e.g. if I take the number "7" and append a series of infinite random numbers between 1 and 5, it's infinite and random but still doesn't include a 7.
19:49:53 <ehird> GregorR-L: Well, yeah, but that's a formality.
20:07:18 <ehird> Things I hate: two people with the same name
20:07:47 -!- GregorR-L has changed nick to ehurd.
20:24:32 <lambdabot> [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,...
20:24:42 <pikhq> Infinite lists! :D
20:25:10 <ehird> pikhq: may I break your mind?
20:25:37 <ehird> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in primelist
20:25:38 <lambdabot> [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101...
20:25:43 <ehird> Mutually recursive primes :-)
20:25:49 <ehird> And infinite lists.
20:25:53 <ehird> Two for the price of laziness!
20:26:06 <pikhq> That is awesome. Also, I knew there was a way to do that, I just wasn't sure exactly what that way was.
20:26:35 * pikhq will have to make his own mutually recursive prime stuff sometime. Possibly later tonight.
20:26:56 -!- asiekierka has joined.
20:27:45 <pikhq> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in primelist
20:27:47 <lambdabot> [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101...
20:28:05 <ehird> pikhq: did you actually change anything there? :P
20:28:27 <pikhq> No. Isn't that how you greet people? With a list of all the primes?
20:29:29 <ehird> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in drop 1000 primelist
20:29:30 <lambdabot> [7927,7933,7937,7949,7951,7963,7993,8009,8011,8017,8039,8053,8059,8069,8081...
20:29:33 <ehird> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in drop 10000 primelist
20:29:36 <lambdabot> [104743,104759,104761,104773,104779,104789,104801,104803,104827,104831,1048...
20:29:44 <ehird> GHC. It's like raw speed in a sufficiently smart can.
20:29:54 <ehird> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in drop 100000 primelist
20:29:59 <lambdabot> mueval-core: Prelude.read: no parse
20:30:32 <ehird> drop takes an Int, doesn't it.
20:30:35 <ehird> @hoogle genericDrop
20:30:35 <lambdabot> Data.List genericDrop :: Integral i => i -> [a] -> [a]
20:30:43 <ehird> pikhq: there's a wart for you, btw.
20:30:50 <ehird> > let isprime n = not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2)) $ primelist; primelist = 2 : [x | x <- [3,5..], isprime x] in genericDrop 100000 primelist
20:30:55 <lambdabot> mueval-core: Prelude.read: no parse
20:31:04 <pikhq> ehird: Where Int is C's int, and Integer is a bignum, basically?
20:31:10 <pikhq> Yeah, that there is a wart.
20:31:12 <ehird> pikhq: Integer is either an int or a bignum.
20:31:17 <ehird> But I think it's long or something actually.
20:31:34 <ehird> pikhq: It's just in there for efficiency; I'd prefer it was named e.g. MachineWord so people didn't use it much.
20:31:48 <ehird> But there's genericX for most X list functions, which sucks.
20:32:02 <pikhq> And the 'drop' function, 'take', etc. take Ints, and genericFoo does Num, IIRC.
20:32:15 <pikhq> Definitely counts as a wart.
20:33:23 * pikhq tries to decipher that isprime function.
20:34:14 <ehird> pikhq: Here's a de-pointlessified version:
20:34:18 <ehird> @unpl not . any ((==0) . (n `mod`)) . takeWhile ((<= n) . (^2))
20:34:18 <lambdabot> (\ g -> not (any (\ m -> (mod n m) == 0) (takeWhile (\ q -> (q ^ 2) <= n) g)))
20:34:34 <asiekierka> ((I'm hopefully getting a portable computer with a 8086 and a programming app onboard so I can make interpreters for esolangs everywhere I am (if i have it and have 2 AA baterries)))
20:34:37 <ehird> and a $ b, as you probably know, is a (b).
20:34:44 <pikhq> ehird: But the pointless one is clear; I'm just taking time to type it out.
20:36:36 <ehird> @pl \x -> foo `fmap` bar x
20:36:43 <ehird> There should be an operator for that.
20:36:48 <ehird> Or rather, a nicer name.
20:37:34 <pikhq> Of the numbers in primelist, square all the ones less than or equal to n, and check if n is divisible by any of them?
20:38:09 <ehird> And since this only depends on numbers strictly less than primelist is calling on us to prime-check, it only ever looks at those we've already considered.
20:38:13 <pikhq> In other words, functional Sieve of Eratosthenes.
20:38:15 <ehird> And thus never gets into an infinite loop.
20:38:22 <ehird> pikhq: — with worse time complexity.
20:38:31 <ehird> It's more of a zen koan than a useful algorithm :P
20:38:39 <pikhq> Because it was implemented like that, yes.
20:38:47 <pikhq> But it is basically that sieve.
20:39:32 <pikhq> According to wikipedia, a more elegant implementation:
20:40:06 <pikhq> > let sieves (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0] in primes = sieves [2..]
20:40:08 <lambdabot> <no location info>: parse error on input `='
20:40:36 <pikhq> > let sieve (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0] in primes = sieve [2..]
20:40:37 <lambdabot> <no location info>: parse error on input `='
20:40:46 <ehird> pikhq: No, that one is pretty much the most elegant due to the infiniteness of the infinite list asking isprime, which then looks at elements of primelist, which would cause it to get trapped in a loop, except we only consider ones we've already done.
20:40:48 <ehird> Can't beat that :-P
20:40:55 <ehird> @hoogle Int->[a]->[a]
20:40:56 <lambdabot> Data.List drop :: Int -> [a] -> [a]
20:41:04 <ehird> Grr, there's no dropFromEnd.
20:41:06 -!- deveah has quit ("MUHAHAHAH!!!1111").
20:41:14 <ehird> Well, reverse . drop n . reverse :-)
20:41:16 <pikhq> ehird: It's pretty nice that isprime is point-free, though.
20:42:13 <ehird> munge = unlines . reverse . drop 2 . reverse . drop 4 . lines
20:43:11 <Deewiant> > iterate (unwords . reverse . drop 2 . reverse . drop 4 . words) (unwords $ replicate 100 "foo")
20:43:12 <lambdabot> ["foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo f...
20:44:03 <pikhq> > unwords . reverse . drop 2 . reverse . drop 4 . words `iterate` unwords $ replicate 100 "foo"
20:44:05 <lambdabot> cannot mix `GHC.Base..' [infixr 9] and `GHC.L...
20:44:14 <pikhq> And correct Haskell. I hate that, too.
20:45:41 * pikhq needs to figure out the freaking precedence of operators. XD
20:46:46 <ehird> Deewiant: Say, do you think "unlines . foo . lines . unlines . bar . lines" will turn into "unlines . foo . bar . lines"?
20:47:39 <Deewiant> "unlines . foo . lines . unlines . bar" might not, though.
20:47:54 <Deewiant> I'm not sure if lines . unlines is always id, but if the input came from lines it should be.
20:48:07 <ehird> @check (\x -> (lines . unlines) x == x)
20:48:08 <lambdabot> "Falsifiable, after 164 tests:\n[\"\\44389\\596659\\562239\\498043\\591429\...
20:48:17 <ehird> Real helpful cutoff there, lambdabot
20:48:25 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
20:48:48 <ehird> > unlines $ lines "\na\n"
20:48:52 <ehird> It is unbreakable!
20:49:02 <pikhq> ehird: ... Check. Really.
20:49:09 <Deewiant> @check \x -> (lines . unlines . map (filter ((< 127).ord)) x == x
20:49:15 <ehird> pikhq: QuickCheck, bitch.
20:49:17 <Deewiant> @check \x -> (lines . unlines . map (filter ((< 127).ord))) x == x
20:49:19 <lambdabot> "Falsifiable, after 1 tests:\n[\"\\45210\",\"\\268475\"]\n"
20:49:20 <pikhq> I don't know if that is merely a good idea or a stunning idea.
20:49:23 <ehird> It's like testing for cool people that don't think up their own lame test data
20:49:34 <SimonRC> lambdabot: hey, you're here too!
20:49:48 <ehird> SimonRC: Yeah, I gave gwern sexual favors and in return e gave us lambdabot.
20:49:52 <Deewiant> @check \x -> let y = filter ((< 127).ord)) x in (lines . unlines) y == y
20:49:56 <ehird> *Story is not strictly historically accurate
20:49:59 <Deewiant> @check \x -> let y = filter ((< 127).ord) x in (lines . unlines) y == y
20:50:00 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
20:50:08 <Deewiant> @check \x -> let y = map (filter ((< 127).ord)) x in (lines . unlines) y == y
20:50:10 <lambdabot> "Falsifiable, after 441 tests:\n[\"\\1009600\\673308\\917019\\918751\\10136...
20:50:11 <ehird> SimonRC: spivak pronouns
20:50:22 <pikhq> SimonRC: Spivak gender-neutral.
20:50:34 <SimonRC> I guessed it was genter-neutral
20:50:52 <Deewiant> @check \x -> (all.all) ((< 127). ord) ==> (lines . unlines) x == x
20:50:59 <SimonRC> I have heard people say that English has perfetly good gender-neutral pronouns
20:50:59 <pikhq> comex: Autistic, actually.
20:51:02 <ehird> Although Spivak changed to ey and emself instead of e and eirself.
20:51:21 <Deewiant> @check \x -> not ((all.all) ((< 127). ord) x) || (lines . unlines) x == x
20:51:28 <Deewiant> @check \x -> not ((all.all) ((< 127). ord) x) || (lines . unlines) x == x
20:51:32 <ehird> 20:50 comex: aspers 20:50 pikhq: comex: Autistic, actually. -- is this meant to make sense?
20:51:32 <Deewiant> @check \x -> not ((all.all) ((< 127). ord) x) || (lines . unlines) x == x
20:51:36 <Deewiant> @smallcheck \x -> not ((all.all) ((< 127). ord) x) || (lines . unlines) x == x
20:51:40 <Deewiant> @scheck \x -> not ((all.all) ((< 127). ord) x) || (lines . unlines) x == x
20:51:49 -!- bsmntbombdood has joined.
20:51:50 <lambdabot> http://code.haskell.org/lambdabot/COMMANDS
20:52:04 <ehird> comex: Ooh, I remember you loling at me for typing badly on that shit keyboard.
20:52:05 <Deewiant> @scheck \x -> (lines . unlines) x == x
20:52:07 <lambdabot> "Falsifiable, after 464 tests:\n[\"\\879457\\149834\\895607\\903638\\981580...
20:52:11 <ehird> WHO'S HIM THE SUBJECT NOW
20:52:22 <ehird> Deewiant: I like how it double-escapes everything
20:52:52 <SimonRC> ehird: the message begins with a " for a reason
20:53:12 <ehird> SimonRC: it begins with a space, actually.
20:53:22 <ehird> > text "Actually, don't blame \"mueval\""
20:53:31 <ehird> I know it's a stirng.
20:53:34 <ehird> But that's STUUUUUUUUUUUUUUUUUUUUUUUUUUPID
20:53:38 <Deewiant> I blame the mueval plugin, it's the same thing.
20:53:44 <ehird> Deewiant: See "text".
20:53:58 <Deewiant> The plugin doesn't do it. It should.
20:54:17 <lambdabot> <no location info>: parse error on input `>'
20:56:14 -!- Judofyr has joined.
21:05:09 -!- asiekierka has quit.
21:05:43 -!- myndzi has quit (Read error: 113 (No route to host)).
21:08:41 -!- myndzi has joined.
21:09:36 -!- bsmntbombdood has quit (Success).
21:21:42 -!- labo has quit ("leaving").
21:31:08 <lambdabot> "\NUL\SOH\STX\ETX\EOT\ENQ\ACK\a\b\t\n\v\f\r\SO\SI\DLE\DC1\DC2\DC3\DC4\NAK\S...
21:31:13 -!- tombom has joined.
21:31:15 <ehird> > reverse ['\0'..]
21:31:17 <lambdabot> "\1114111\1114110\1114109\1114108\1114107\1114106\1114105\1114104\1114103\1...
21:31:18 -!- Judofyr_ has joined.
21:31:21 <ehird> pikhq: FEAR THE UNICODE.
21:32:23 <ehird> pikhq: Disclaimer: default IO methods don't do Unicode because they're crap, so use utf8-strings when it matters.
21:33:16 <pikhq> ... It makes Unicode require effort?
21:33:17 * coppro wants a language where the basic character type is a true unicode character
21:33:34 <pikhq> I may have to go back to Tcl, which has done Unicode for everything for 10 years.
21:33:58 <pikhq> Everything is a string, and all strings are Unicode.
21:33:59 <ehird> coppro: Uh, that's Haskell.
21:34:06 <ehird> Just import utf8-strings's modules.
21:34:11 <ehird> They act exactly like the regular IO.
21:34:15 <ehird> But they do UTF-8.
21:34:22 <ehird> And the actual "Char" type is Unicode, through and through.
21:34:23 <coppro> ehird: no. if it's a utf8-string, it's not a true unicode character
21:34:31 <coppro> I doubt Tcl has it either
21:34:31 <ehird> Char is a true unicode character.
21:34:32 <pikhq> Bu,but that is one line of code that shouldn't be there!
21:34:43 <SimonRC> coppro: if you like dynamic types, try factor, whose string are sequences specialised to one type (1-cell integers)
21:34:44 <coppro> ehird: including combining characters?
21:34:55 <ehird> > reverse ['\0'..]
21:34:57 <lambdabot> "\1114111\1114110\1114109\1114108\1114107\1114106\1114105\1114104\1114103\1...
21:34:58 <pikhq> Tcl uses an internal representation of UTF-16 for convenience.
21:34:59 <ehird> It is the full unicode character set.
21:35:02 <SimonRC> factor strings are just sequences of codepoints
21:35:05 <ehird> The default IO stuff just doesn't handle it.
21:35:08 <ehird> SimonRC: ditto w/ haskell
21:35:17 <ehird> pikhq: in ghc head SPJ added a new io system thing, btw, that does unicode
21:35:21 <ehird> so it'll be fixed in N time
21:35:34 <pikhq> ehird: Okay, then. Sanity shall preval.
21:35:35 <coppro> ehird: is Char one character or one code point
21:35:40 <ehird> coppro: code point.
21:35:51 <SimonRC> UTF-16 is a great anti-compromise... you can't make the assumtions that a 32-bit encoding allows, but it still takes up loads of space
21:36:04 <ehird> it fails in the sense that it's predictable and not kooky like using characters would b
21:36:08 <coppro> eh, 32-bit doesn't allow those assumptions either
21:36:12 <coppro> combining characters made sure of that
21:36:22 <SimonRC> coppro: um, one character can be a sequence of hundreds of codepoints
21:36:25 <ehird> characters aren't important
21:36:35 <SimonRC> and what *is* a character anyway?
21:36:35 <ehird> that's the reason they are code points
21:36:41 <ehird> a character is ill-defined
21:37:10 <SimonRC> coppro: so, you want a computer to do something you know is ill-defined?
21:37:15 <coppro> I'm sure that I could come up with an adequate definition
21:37:15 <SimonRC> as a basic part of the anguage
21:37:43 <SimonRC> well, one could have a language in which strings aren't sequences
21:37:54 <AnMaster> http://omploader.org/vMXZoMw <-- nice graph. Long live graphviz!
21:37:57 <ehird> coppro: it's not a useful definition though.
21:38:00 <SimonRC> strings can be divided into substrings, which can be of zero length, etc
21:38:11 <ehird> SimonRC: ehhhhhhhh
21:38:12 <AnMaster> red is IO, blue is "dummy to make everything go from start"
21:38:13 <ehird> that's just sublists
21:38:17 <SimonRC> and you can't index them, because that will eventually cause problems
21:38:21 <coppro> working with normalized uncomposed strings is the next-best thing
21:38:23 <AnMaster> (I forgot the fancy name for it)
21:38:23 <SimonRC> like python strings XTREME
21:38:57 <AnMaster> the plan is to convert this into some sort of SSA form next
21:39:11 <ehird> AnMaster: CPS bitch.
21:39:22 <ehird> AnMaster: CPS = SSA.
21:39:25 <ehird> They are equivalent.
21:39:33 <AnMaster> ehird, true. but SSA is simpler to think in
21:39:59 <AnMaster> at least when working on a imperative language
21:40:00 <SimonRC> AnMaster: what is that graph?
21:40:12 <AnMaster> SimonRC, dependency graph inside a basic block.
21:40:25 <AnMaster> +>,<[>]>[-]+++>++>[-]>,<<<[->++>+++>+<<<].>.>>>,.<<.>.>,[->+++<]>.
21:40:27 -!- Judofyr has quit (Nick collision from services.).
21:40:31 <ehird> AnMaster: no, they're equivalent
21:40:32 -!- Judofyr_ has changed nick to Judofyr.
21:40:37 <ehird> just a trivial syntactic transformation
21:40:53 <AnMaster> so that is in a separate graph
21:41:11 <SimonRC> you're taking this BF thing seriously
21:41:15 <AnMaster> currently I can't do any sort of loops or ifs inside graphs, but I plan to change that
21:41:22 <AnMaster> at least if should be possible
21:41:27 <SimonRC> does it go at a not-ridiculously-slow speed now?
21:42:04 <AnMaster> SimonRC, it takes about a minute to compile LostKing on my 2 GHz Sempron 3300+ running x86_64 code
21:42:26 <AnMaster> with HIPE you save maybe 10 seconds
21:42:42 <SimonRC> ah, the compiler is in Erlang?
21:42:43 <AnMaster> basically compiles stuff to native code instead of byte code
21:43:15 <AnMaster> SimonRC, and no, it isn't very optimised for fast compilation
21:43:20 <ehird> make it in bf instead.
21:43:23 <AnMaster> but rather, for best possible output
21:43:30 <SimonRC> is it a very thready compiler?
21:43:59 <SimonRC> is the output much faster?
21:44:00 <AnMaster> SimonRC, no, and since I have a single core, I can't really test where there may be gains from that.
21:44:12 <AnMaster> and yes, it is much faster than non-optimised C output
21:44:14 <SimonRC> and does it spot things that a human wouldn't?
21:44:28 <AnMaster> SimonRC, err what do you mean "<SimonRC> and does it spot things that a human wouldn't?"?
21:44:36 <ehird> exactly what he said
21:44:44 <SimonRC> does it optimise better than a human
21:44:49 <AnMaster> I would probably miss stuff in lostking if I tried to hand-compile to C
21:44:59 <SimonRC> (except when the human has figured out what the program does)
21:45:12 <AnMaster> SimonRC, I can see some cases it could do better.
21:45:19 <AnMaster> on the other hand it surprised me today
21:45:43 <AnMaster> SimonRC, "how could that while loop turn into that much shorter if?, Doesn't make sense, must be yet another bug"
21:45:50 <AnMaster> but it turned out it was right
21:47:38 <AnMaster> that is a diff between "what it produced before, what it produced after"
21:47:46 <ehird> that diff format is really useless for comparison.
21:48:03 <AnMaster> ehird, I can read it just fine
21:48:14 <AnMaster> so you see some bits in red and other in blue
21:48:27 <AnMaster> colordiff is a very very very nice tool
21:49:05 <ehird> but the two things aren't semantically related
21:49:15 <ehird> matching lines are purely coincidental, it's not a patch to what it says
21:49:19 <ehird> it's a fundamental restructuring
21:49:29 <AnMaster> but that is what a single code change did
21:49:34 <AnMaster> the thing that caused that diff was adding graph-based DCE
21:49:43 <ehird> pointless talking to someone so literally minded
21:49:45 <AnMaster> so it can see "if this is never used, remove it"
21:49:54 <AnMaster> and that was the bit that surprised me
21:50:03 <AnMaster> ehird, I have no idea how else to show this
21:50:10 <AnMaster> since it is near the middle of listking
21:51:31 <AnMaster> SimonRC, so yes, I guess it sometimes spot stuff humans wouldn't
21:51:40 <AnMaster> but sometimes it is extremely dumb
21:51:50 <ehird> side-by-side is the best way to compare two fundamentally different statings of the same thing
21:51:59 <ehird> not a diff that happens to match up some lines in them
21:52:16 <AnMaster> ehird, so convert it. I don't know how to generate a side by side diff using diff(1)
21:52:32 <ehird> AnMaster: ... if it's side by side it's not a diff
21:52:36 <ehird> it's just the two pieces of code side by side
21:52:48 <AnMaster> so just undiff it,. Easy enough from that code
21:53:12 <AnMaster> take one containing those line starting with space or minus, another those lines starting with space or plus
21:53:29 <ehird> i was merely questioning the efficacy of distributing it in a less-suitable format
21:53:40 <AnMaster> SimonRC, example of it not so smart: p[1]=~p[8];\np[8]=p[1];\np[1]=0;
21:53:46 <AnMaster> though it handles that one now too
21:54:10 <AnMaster> but I still see "stupid" stuff.
21:54:14 <AnMaster> ehird, I didn't have a problem with it
21:54:18 <ehird> i thought generally just 0→1,1→0 was coded
21:54:21 <SimonRC> BTW, the last two lines of what you shoed me can be moved out of the if
21:54:40 <AnMaster> ehird, no, that is the C backend seeing y=-1-x and peepholeing it into y=~x
21:54:45 <ehird> moving outside of a conditional ain't gonna help performance
21:54:49 <ehird> it just makes you execute more stuff...
21:55:05 <SimonRC> but it might help other optimisations
21:55:07 <ehird> AnMaster: any C compiler that can't do that is really rubbish
21:55:15 <SimonRC> and p[113] must have been a hell of a lot of >>>> <<<<
21:55:29 <AnMaster> SimonRC, um, other optimisations know very well that p[0]=0; after already.
21:55:46 <Deewiant> http://pastebin.ca/1471637 separated
21:56:10 <AnMaster> they know that because for loops the loop doesn't exit if index cell != 0; or for if because they ask the introspection code about it.
21:56:35 <ehird> Deewiant: you are like unto a flower.
21:57:03 <ehird> that's just in the other one
21:57:09 <AnMaster> SimonRC, worth investigating if it will help or not.
21:57:34 <ehird> i'm not sure why you're so surprised that it optimized it :p
21:57:38 <AnMaster> ehird, I don't use negative numbers.
21:58:06 <Deewiant> If it were 256 it'd be an infinite loop anyways, not an if.
21:58:46 <AnMaster> p[113]+=p[0]; is easy to explain. Once that loop was simplified enough to not have deps on cells written in the previous iteration, it was turned into a set of polynomials inside an if
21:59:04 <AnMaster> the if was required due to the sets there
21:59:17 <SimonRC> what does "polynomials" mean here?
21:59:29 <ehird> SimonRC: what it normally does
21:59:37 <ehird> In mathematics, a polynomial is a finite length expression constructed from variables (also known as indeterminates) and constants, using the operations of addition, subtraction, multiplication, and constant non-negative whole number exponents.
21:59:44 <AnMaster> SimonRC, [{Coeff,[{Offset,Exponent},...]},...]
21:59:51 <ehird> although really, it's just used to mean "a bunch of mathematical relationships on variables" in the bf compiler world.
22:00:05 <AnMaster> ehird, in this case it is actually stored as a polynomial
22:00:13 <ehird> AnMaster: well that's pointless.
22:00:17 <AnMaster> ehird, it is a lot easier to simplify
22:00:39 <SimonRC> AnMaster: might it be a good optimisation to keep bit vectos of what values each singly-assigne variable could have at each point?
22:01:06 <AnMaster> ehird, I tried writing generic expression manipulation code. Ended up with some 500 lines, and that didn't properly simplify all cases. The polynomial code is less than 300 lines, including the "visitor pattern" code used by the backend(s)
22:01:39 <AnMaster> SimonRC, it might. But that graph I showed isn't yet in SSA form. I planned to work on that bit tomorrow
22:02:00 <AnMaster> the graph also currently contains ordering info and lots more (though that wasn't dumped to the dot file)
22:02:20 <AnMaster> however, I learnt a lot during making this
22:02:38 <AnMaster> I even made a simple DCE/single-use-propagator pass on the graph to test it.
22:02:55 <AnMaster> still needs to be turned into proper SSA form though
22:04:08 <AnMaster> SimonRC, with no edges excluded it looks like this currently: http://omploader.org/vMXZoOA
22:04:25 <AnMaster> dotted is "order", green is, um, complex to explain.
22:04:42 <AnMaster> "definition overwritten, but not read"
22:04:48 <AnMaster> would be the best way to explain it.
22:06:03 <AnMaster> a lot messier, but at least the ordering info is needed atm, will not be needed once it is turned into SSA form.
22:06:46 <AnMaster> (and the other one was added for debugging)
22:06:46 <SimonRC> SSA can reach "round" loops, right?
22:07:25 <AnMaster> SimonRC, err, how? I figured out "if" easily enough. And yes I guess if variable isn't changed inside the loop it can reach round it
22:07:39 <AnMaster> you can't handle unbalanced BF loops though
22:08:05 <AnMaster> SimonRC, but I don't know how to handle something like ,[.,] in SSA
22:08:38 <SimonRC> I think compiler books cover that sort of thing too
22:08:41 <AnMaster> if is "trivial", just some phi nodes
22:09:10 <SimonRC> you could get the Dragon Book
22:09:23 <SimonRC> that covers lots of front-end stuff too though
22:09:32 <ehird> AnMaster: just buy the damn thing
22:09:43 <ehird> although personally I think you should instead opt for
22:09:44 <AnMaster> ehird, don't like dead paper edition
22:09:49 <ehird> .............. wait for it
22:09:56 <ehird> AnMaster: buy a kindle :P
22:10:08 <AnMaster> ehird, I read SICP, but I don't remember SSA form there?
22:10:50 <ehird> http://thepiratebay.org/torrent/3635514/Compilers_-_Principles__Techniques_and_Tools_(First_Edition__198
22:11:14 <AnMaster> ehird, that would hurt to read
22:11:24 <ehird> AnMaster: ,[.,] in SSA? how is that hard?
22:11:33 <AnMaster> ehird, describe how it is done then
22:11:45 <ehird> http://en.wikipedia.org/wiki/Static_single_assignment_form
22:13:57 <AnMaster> ehird, that doesn't describe loops...
22:14:46 <AnMaster> ehird, so try again, if you plan to link, please link something relevant.
22:19:41 -!- ehurd has quit (Read error: 110 (Connection timed out)).
22:28:57 -!- Gracenotes has quit (Read error: 60 (Operation timed out)).
22:29:08 <AnMaster> ehird, suite yourself, ignore it.
22:30:09 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
22:31:22 <AnMaster> tombom, isn't that the right English phrase?
22:31:37 <tombom> suite means something different
22:31:52 <AnMaster> tombom, what does the suit one mean?
22:32:09 -!- Judofyr has quit (Remote closed the connection).
22:32:32 * AnMaster probably never noticed the difference between suit and suite
22:33:06 <GregorR> A suite is a deluxe accommodation.
22:33:20 <GregorR> Or, what somebody has decided to pretend is deluxe, anyway :P
22:33:39 <GregorR> e.g. At a hotel, the honeymoon suite is the best room, and the other suites are nearly as good, and the other rooms suck as compared to the suites.
22:33:45 <tombom> or a collection of things
22:34:03 <GregorR> That too, but it sounded more like my meaning on context :P
22:34:08 <GregorR> And also, it's not a sofa.
22:34:24 <GregorR> `addquote <SimonRC> TODO: sex life
22:34:25 <HackEgo> 11|<SimonRC> TODO: sex life
22:34:42 -!- tombom has quit ("Peace and Protection 4.22.2").
22:36:17 <ehird> 22:34 SimonRC: TODO: sex life ← WONTFIX
22:38:14 <GregorR> Are you ... SUUUUUUUUUUUURE
22:39:39 <pikhq> You wanna have fun?
22:40:00 <AnMaster> <ehird> AnMaster: ,[.,] in SSA? how is that hard?
22:40:01 <AnMaster> <AnMaster> ehird, describe how it is done then
22:40:01 <AnMaster> <ehird> http://en.wikipedia.org/wiki/Static_single_assignment_form
22:40:01 <AnMaster> <AnMaster> ehird, that doesn't describe loops...
22:40:10 <pikhq> I eventually got a stack overflow! Yay!
22:40:22 <ehird> AnMaster: no, i just don't feel like helping you
22:41:36 <ehird> pikhq: please clarify for the young gentlemen AnMaster here that I have no interest in helping dickwads, assholes, idiots or any other such uncouth persons and it is strictly personal, not a matter of lack of success
22:41:38 <AnMaster> ehird, I asked ais and he said he didn't know, but that "generally you break SSA for loops slightly"
22:41:40 <ehird> there's a good boy
22:41:53 <AnMaster> so I guess you don't know either
22:42:07 <ehird> right. because knowledge(ehird) strictly-subset-of knowledge(ais523).
22:42:28 <AnMaster> ehird, no it isn't, but the way you act...
22:42:47 <pikhq> AnMaster: I think what he means to say is "main = print [0..]".
22:42:50 <ehird> that's because i like irritating you, AnMaster.
22:43:08 <ehird> pikhq: Fun fact: ghc has an oracle. Try running "main = main".
22:43:12 <pikhq> And stick that in a file.
22:43:14 <AnMaster> pikhq, not sure what you mean with that though.
22:43:23 <AnMaster> pikhq, since I don't know haskell
22:43:48 <pikhq> AnMaster: That would be all positive integers.
22:44:28 <pikhq> But whaddya mean, an oracle?
22:44:47 <AnMaster> so you mean Vx = phi(V0,...Vn) basically?
22:44:54 <pikhq> It certainly isn't an oracle machine, and this sure as fuck ain't halting.
22:45:03 <pikhq> AnMaster: Yes. Except that you should stick it in a file.
22:45:03 <ehird> Oh, lambdabot doesn't do IO.
22:45:06 <lambdabot> [0,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,...
22:45:21 <ehird> [ehird:~/Junk] % echo 'main=main'>foo.hs;ghc foo.hs -o foo;./foo
22:45:28 <ehird> you tell me that isn't the work of a halting oracle!
22:46:02 <pikhq> Has different behavior with runhaskell.
22:46:35 <AnMaster> pikhq, infinite lists == blergh if language doesn't support it.
22:47:36 * pikhq looks at ghc's C output...
22:47:43 <AnMaster> pikhq, plus I have a DAG here...
22:48:35 <AnMaster> guess I need cycles for SSA form then
22:49:13 <ehird> pikhq: don't use -fvia-C
22:49:25 <ehird> the native code generator is as good most of the time and sometimes better :P
22:49:40 <ehird> pikhq: oh, did you know? GHC, after compiling the C code, then runs the asm through a perl script that changes calls into jumps.
22:50:05 <ehird> pikhq: Also, this script is "literate perl", which is a one-off format designed just for ghc that basically reverses comments/code (so that code is prefixed instead of comments).
22:50:19 <ehird> It is "compiled" (trivially translated) to perl in the compilation process.
22:50:24 <ehird> pikhq: 's called the Evil Mangler. :)
22:50:28 <pikhq> ... Because it doesn't need the stack at all. LMAO
22:50:48 <pikhq> That is beautiful. Epic hack, though.
22:51:50 <pikhq> Redundancy is redundant.
22:52:09 <olsner> there's also the Satanic Splitter, which is another revered/feared perl script
22:52:23 <olsner> also some assembly post-processing iirc
22:52:41 <ehird> i haven't heard of the Satanic Splitter before now
22:52:49 <ehird> olsner: the mangler is the asm post-processing
22:53:00 <olsner> http://markmail.org/message/blmoqkkooqezr3p4
22:53:04 <pikhq> Where can I find this evil Perl?
22:53:20 <ehird> pikhq: ghc_source_tree
22:53:42 <ehird> pikhq: $prefix/local/lib/ghc-version/ghc-asm
22:53:44 <ehird> if you don't need the comments.
22:54:06 <AnMaster> ehird, why this literate perl. I mean, *why*
22:54:10 <ehird> last procedure is "tidy_up_and_die"
22:54:17 <ehird> AnMaster: because the mangler needs a lot of explaining
22:54:44 <AnMaster> the bit that reversed it to normal perl probably needs a bit of explaining too I imagine!
22:54:53 <olsner> this looks like some kind of reference: http://hackage.haskell.org/trac/ghc/wiki/Commentary/EvilMangler
22:54:54 <ehird> pikhq: http://darcs.haskell.org/ghc/driver/mangler/ghc-asm.lprl
22:54:56 <ehird> the literate version
22:55:48 <pikhq> And, of course, it's commented via TeX.
22:56:33 <pikhq> Makes sense, given that TeX is the ultimate example of a literate program. :P
22:56:42 <ehird> have you ever read the original one?
22:56:46 <ehird> god, that pascal is _awful_
22:57:04 <AnMaster> olsner, what is the splitter used for really
22:57:50 <AnMaster> ehird, I have not read it, but I have glanced at it.
22:58:01 <ehird> i was talking to pikhq..
22:58:02 <olsner> I think I'm remembering what it does now... it splits up object files to allow static linking to throw away more of the unused parts of the static library
22:58:04 <AnMaster> ehird, "things" == object files?
22:58:24 <ehird> unsuspecting victims that can say SplitObjs=NO at any time, but when
22:58:25 <ehird> they do, it punishes them with multi-megabyte executables"
23:03:18 <AnMaster> ehird, so what does it split out of the object files?
23:04:20 <olsner> it's doing something similar to --gc-sections and --function-sections (don't remember the precise placing of the hyphens, but something like that it is), only manually
23:06:20 <AnMaster> you mean ld's "--gc-sections"?
23:06:44 <AnMaster> --function-sections isn't ld at least
23:07:04 <AnMaster> olsner, simplest way is one object file / function
23:08:07 <olsner> yes, I think that's what the splitter makes it
23:16:46 -!- MigoMipo has quit ("QuitIRCServerException: MigoMipo disconnected from IRC Server").
23:24:36 -!- jix_ has joined.
23:36:40 -!- jix has quit (Read error: 113 (No route to host)).
23:37:54 -!- coppro has changed nick to ze23||||||-.
23:38:48 -!- ze23||||||- has changed nick to ze23}{||||||-.
23:40:10 -!- ze23}{||||||- has changed nick to coppro.
23:42:22 -!- BeholdMyGlory has quit (Remote closed the connection).
23:48:15 -!- coppro has changed nick to IgnisCaelum.
23:48:19 -!- IgnisCaelum has changed nick to coppro.
23:50:57 -!- GreaseMonkey has joined.