00:00:15 <oerjan> elliott_: since 32 has so many factors, the gcd rule is likely to cut that down more than 34 which is twice a prime. i think.
00:01:23 <elliott_> oerjan: would it be possible to make some sort of progress report output? :P
00:03:32 <elliott_> oerjan: well i could always report progress through the original list passed, right?
00:03:36 <elliott_> that would be rather non-finegrained though
00:04:45 <oerjan> um but those are done in parallel...
00:05:54 <elliott_> [[Two things - firstly: "Every time you do any string handling with C's native string types and functions, you need to make sure you have allocated enough memory for each string" - that's right, and experienced C developers write the correct code naturally and without thinking.]]
00:06:00 <elliott_> humans are infallible and busywork is good
00:06:49 <oerjan> as i've almost said before, with perfect people everything works, even nazism
00:07:16 <pikhq> oerjan: Even sparks can be destroyed by overhead, but 99% of the time, it "just works".
00:07:44 <pikhq> (those suckers are *really* cheap)
00:08:22 <zzo38> Understanding probability can help to play at pokemon card!
00:10:01 <elliott_> "That's silly - almost all programs use strings heavily, considering that they're really the most natural way for programs to take input from and produce output for humans."
00:10:09 <elliott_> and that's why everyone uses text UIs, without even colour or cursor control
00:11:11 <zzo38> I am playing CLEFAIRY [Lv15] against DARK CLEFABLE [Lv33] and I think my chance of hitting them is 50%. Their chance of hitting me is probably lower, but I don't know the exact amount. It is not greater than 50% though.
00:12:42 <ais523> Pokémon names aren't officially always-uppercased nowadays
00:13:02 <ais523> although it's a relatively recent change
00:13:18 <zzo38> coppro: No link, sorry.
00:13:40 <ais523> Bulbapedia has most of the older Pokémon cards, but they're sorted by expansion, rather than zzo38's naming scheme
00:13:42 <zzo38> ais523: I am uppercased the names of all the cards
00:14:07 <zzo38> ais523: Do you know how to play pokemon card?
00:14:28 <zzo38> See if you understand my puzzle games.
00:14:47 <elliott_> Cords are a nice structure; I wonder if they're efficient when implemented purely functionally.
00:15:02 <zzo38> elliott_: Can you try it and figure out?
00:15:06 <ais523> it'll be complicated by the fact that zzo38 likely plays a mix of old rulesets
00:15:16 -!- CakeProphet has quit (Read error: Connection reset by peer).
00:15:44 <zzo38> http://zzo38computer.cjb.net/textfile/miscellaneous/pokemon_card/puzzle.1
00:15:46 <zzo38> http://zzo38computer.cjb.net/textfile/miscellaneous/pokemon_card/puzzle.2
00:15:51 -!- CakeProphet has joined.
00:15:51 -!- CakeProphet has quit (Changing host).
00:15:51 -!- CakeProphet has joined.
00:16:43 <ais523> ah, DARK CLEFABLE [Lv33] is more commonly called Dark Clefable (Team Rocket's Ambition) or Dark Clefable (GB 2)
00:16:55 <ais523> so that was easy enough to find: http://bulbapedia.bulbagarden.net/wiki/Dark_Clefable_%28GB_2%29
00:17:05 <zzo38> Yes it is the GB 2 version.
00:17:09 <elliott_> | Branch !Int !(Maybe (Cord l a)) !(Maybe (Cord l a))
00:17:31 <zzo38> Calling it [Lv33] should still be unambiguous, though. Also, the puzzle games list all the card texts.
00:17:44 <ais523> and hmm, is exclusive to one of the Game Boy games, rather than being an actual physical card
00:19:07 <zzo38> Yes it is, although it could be played with physical cards too I think, if the chance os 1/3 for -0, 1/3 for -1, 1/3 for -2, then you can use a dice however, which is not part of the standard game.
00:19:35 <zzo38> (These are also the numbers I used to estimate my probability of hitting)
00:22:10 <oerjan> elliott_: your newtype has some spurious l's
00:22:23 <elliott_> oerjan: indeed, remnants from a previous, more general attempt that I'm delaying
00:22:28 <elliott_> oerjan: ([a] is not a very efficient short-string structure)
00:23:04 <elliott_> "Leaf nodes (as well as some single-child internal nodes) also contain a short string."
00:23:07 <elliott_> i love that unexplained as-well-as
00:23:42 <elliott_> "Seen from another perspective, the binary tree of a rope can be seen as several levels of nodes. The bottom level contains all the nodes that have a short string. Higher levels have fewer and fewer nodes, until finally there is just one root node in the top level. We can build the rope by putting all the nodes with short strings in the bottom level, then randomly picking half those nodes in order to form parent nodes in the next level. Nodes with no p
00:23:42 <elliott_> arent (for example, the two nodes storing the strings "my_" and "me_i" in the diagram above) become the right child of the node located immediately to their left, thus forming a chain. In this way, we can build higher levels one level at a time. We stop when there is only one node remaining."
00:23:51 <elliott_> it's like it's purposefully trying not to be an actual algorithm
00:24:00 <zzo38> The GameBoy computer opponents seem to be bad at defensive play and average at offensive play, and often do stupid things.
00:24:15 <zzo38> ais523: Can you figure out my puzzle games? Can you understand it?
00:24:36 <coppro> zzo38: Referring to cards by level is a bad approach
00:24:46 <coppro> zzo38: The cards are much more well-known by name
00:25:16 <elliott_> oerjan: hmm, looks like finger trees are actually pretty close to this
00:25:20 <zzo38> The card texts of the puzzles are typed on there
00:25:30 <zzo38> And anyways I only know them by level anyways
00:25:43 <elliott_> oerjan: finger trees have O(n) indexing, right?
00:26:00 <elliott_> i guess because it tries from the end too
00:26:05 <ais523> zzo38: I haven't looked at it, I'm watching a Pokémon Blue TAS at the moment
00:26:56 <oerjan> elliott_: finger trees have O(1) indexing at the end, is the major difference i think
00:27:24 <elliott_> oerjan: that's actually quite useful, for strings
00:27:42 <coppro> a pokemon TAS? oh dear
00:27:56 <elliott_> oerjan: the problem is that you don't want (Seq Char), you want (Seq AboutSixteenOrSoChars)
00:28:00 <elliott_> oerjan: which just complicates every algorithm
00:28:09 <elliott_> sufficiently so that I think reinventing the wheel might be more expedient
00:28:39 <oerjan> elliott_: the O(1) also keeps holding a*ly as you traverse inwards
00:28:55 <elliott_> yes, that is definitely a sentence that makes sense.
00:29:08 <oerjan> a* is here the word i keep forgetting
00:29:21 <zzo38> What is a Pokemon TAS?
00:31:49 <elliott_> http://hackage.haskell.org/packages/archive/simple-rope/0.1/doc/html/Data-Rope.html ;; TYPE FAMILIES: TOTALLY SIMPLE
00:31:53 <oerjan> anyway, the first 16 chars take 16*O(1) to traverse
00:32:36 <Sgeo> elliott_ hates history
00:32:41 <Sgeo> and historical stuff
00:33:43 <elliott_> oerjan: hmm, http://upload.wikimedia.org/wikipedia/commons/c/c2/Rope_example.jpg confuses me
00:33:51 <elliott_> apart from being tilted for no apparent reason, the lengths of the strings all vary wildly
00:33:59 <elliott_> is it because of inserting "s" somewhere that there's a one-char "s"?
00:37:08 <oerjan> and the numbers only apply to the part vertically below ignoring the tilting...
00:38:07 <elliott_> oerjan: I just mean, why would all the strings not be equally-sized?
00:38:15 <elliott_> So presumably it isn't a newly-created string, but a modified one
00:38:30 * oerjan doesn't actually know ropes
00:38:48 <oerjan> i think i briefly considered if they were useful for implementing dupdog
00:39:24 <oerjan> ok i guess if there isn't more to them than that, i know them
00:39:36 <zzo38> It is impossible to pull the ropes regardless of the number of your tentacles, I think.
00:40:28 <oerjan> maybe zzo38 is a great old one
00:41:20 <zzo38> Actually I am not one million years old. Nobody lives that long, I think.
00:44:17 -!- ralc has quit (Quit: Leaving).
00:47:24 <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
00:47:32 <elliott_> there is probably some obvious answer based on keeping the tree shallow
00:47:43 <elliott_> well, shallow but still... foresty enough
00:51:53 <Sgeo> RIP Bonobo Conspiracy
00:52:59 -!- azaq23 has quit (Quit: Leaving.).
00:53:52 * elliott_ was hoping oerjan would answer :D
00:54:01 <elliott_> 4004 elliott 20 0 48740 3984 1260 S 109 0.1 124:00.04 nsearch.optim
00:55:07 <elliott_> <kmc> only in Haskell would you rotate a list by extending it to be infinitely long and then throwing out most of it ;P
00:55:49 -!- Phantom_Hoover has quit (Quit: Leaving).
00:56:15 <oerjan> > let rot n l = take (length l) . drop n $ cycle l in rot 5 "abracadabra"
00:56:19 <elliott_> LinuxJournal: Is there a world outside of computers?
00:56:19 <elliott_> -- http://www.linuxjournal.com/article/5048
00:56:39 <oerjan> elliott_: * elliott_ was hoping oerjan would answer :D
00:56:52 <elliott_> oerjan: <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
00:56:53 <elliott_> <elliott_> there is probably some obvious answer based on keeping the tree shallow
00:56:53 <elliott_> <elliott_> but I don't know what it is
00:56:53 <elliott_> <elliott_> well, shallow but still... foresty enough
00:57:02 <elliott_> oerjan: also, the reason no haskell compiler does automatic memoisation is because of space leaks, right?
00:58:52 <elliott_> http://www.reddit.com/r/programming/comments/ifq59/a_regular_expression_matcher_in_30_lines_of_c/c23fz1d?context=3 hey oerjan, tell me whether my response is bullshit or not :P
01:00:05 -!- jcp has joined.
01:01:39 <oerjan> sounds fair. although i vaguely recall at one time reading that main = putStrLn "hello" >> main
01:01:40 <lambdabot> Prelude replicate :: Int -> a -> [a]
01:01:40 <lambdabot> Data.List replicate :: Int -> a -> [a]
01:01:40 <lambdabot> Control.Monad replicateM :: Monad m => Int -> m a -> m [a]
01:01:47 <lambdabot> Control.Monad replicateM :: Monad m => Int -> m a -> m [a]
01:02:01 <oerjan> elliott_: how dare you paste in the middle of my broken line
01:02:13 <elliott_> anyway, it won't blow the stack
01:02:14 <oerjan> elliott_: er, *did leak space
01:02:16 <elliott_> even if it does eat all your ram
01:02:31 <oerjan> this was in some ancient version
01:03:02 <oerjan> elliott_: what do you want for that ?hoogle function?
01:03:20 <elliott_> oerjan: group into lists of length N
01:03:32 <elliott_> "abcdefgh" grouped by three -> ["abc","def","gh"]
01:03:36 <oerjan> elliott_: Data.Split, i think
01:03:53 <oerjan> not in standard libraries
01:04:58 <oerjan> > takeWhile (not.null) . map(take 3) . iterate(drop 3) $ "abcdefgh"
01:09:49 -!- Sgeo has quit (Ping timeout: 255 seconds).
01:10:33 -!- Sgeo has joined.
01:15:10 <elliott_> http://hackage.haskell.org/packages/archive/ListLike/3.1.1/doc/html/Data-ListLike.html#t:ListLike ugliest typeclass
01:15:28 <pikhq> elliott_: Should I feel bad for having made sabotage build dynamically?
01:15:40 -!- Sgeo has quit (Ping timeout: 255 seconds).
01:15:49 <pikhq> Well, that was straightforward.
01:16:42 <pikhq> elliott_: It also seems to have cut the size of X11 by 95%.
01:17:59 <zzo38> Does the Linux kernel have support for error emulation?
01:19:48 -!- jcp|other has joined.
01:19:55 -!- jcp|other has quit (Read error: Connection reset by peer).
01:20:14 -!- jcp|other has joined.
01:23:48 -!- Sgeo has joined.
01:26:58 -!- CakeProphet has quit (Ping timeout: 260 seconds).
01:33:32 <elliott_> oerjan: that was actually to answer my implicit question IN RETURN FOR ALL MY CPU TIME
01:33:32 <oerjan> also you beat me by seconds there
01:33:44 <elliott_> <elliott_> oerjan: <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
01:33:44 <elliott_> <elliott_> <elliott_> there is probably some obvious answer based on keeping the tree shallow
01:33:44 <elliott_> <elliott_> <elliott_> but I don't know what it is
01:33:44 <elliott_> <elliott_> <elliott_> well, shallow but still... foresty enough
01:34:01 <oerjan> i think i can say with some confidence that i dunno
01:34:06 <elliott_> I dunno whether you want it to be some fraction of the total initial string length or some constant :D
01:34:29 <oerjan> elliott_: square root or logarithm perhaps?
01:34:40 <oerjan> hm but you want a lower limit too
01:34:44 <elliott_> yes, let's just throw random functions at the problem :D
01:35:11 <oerjan> gaussian, to be precise
01:35:40 <elliott_> pack :: (StringLike a) => Int -> a -> Rope a
01:35:40 <elliott_> pack cs s | size s < 2*cs = Leaf cs s
01:35:40 <elliott_> | otherwise = let (a,b) = splitAt cs s in pack cs a <> pack cs b
01:35:47 <oerjan> _finally_ elliott_ is getting a clue
01:36:31 <elliott_> -- | O(n) Convert a list of 'Word8' into a 'Rope'
01:36:32 <elliott_> if Prelude.length s<=leafSize then unsafePerformIO $ do
01:36:32 <elliott_> contents<-mallocForeignPtrArray leafSize
01:36:36 <elliott_> withForeignPtr i0 $ \i->poke i $ Prelude.length s
01:36:38 <elliott_> withForeignPtr contents $ \c->fillPtr c s
01:36:40 <elliott_> return $ String { contents, i0, offset=0, length_=Prelude.length s }
01:36:44 <elliott_> let (a,b)=Prelude.splitAt leafSize s in
01:36:50 <elliott_> fillPtr::Storable a=>Ptr a->[a]->IO ()
01:37:04 <elliott_> \end{code} Il n'est pas clair qu'on ne puisse pas faire beaucoup mieux que ce pack. Par exemple, vu qu'on calcule la taille de la liste, on pourrait sortir un arbre directement \'equilibr\'e. Vu qu'on ne fait jamais pack avec des 'ByteString's (sauf ghc quand il compile des IsString), \c ca ne vaut sans doute pas le co\^ut. Par contre, append est utilise presque partout. Il est crucial que son implementation soit extremement efficace. \begin{code}
01:37:13 <elliott_> so the ideal chunk size is between 64 and 65536
01:39:56 <oerjan> wait this is the kind of "you need no know cache" stuff, isn't it.
01:41:33 <Sgeo> Newspaper works as a mousepad!
01:41:41 <elliott_> Sgeo: Warren considers my ardent anti-historism beautiful.
01:43:52 <elliott_> oerjan: 208:18.92 nsearch.optim
01:46:22 <oerjan> are you _sure_ you didn't accidentally write 43 or something
01:51:02 <elliott_> main = print (nsearch 34 1 0 [1..33])
01:51:34 <elliott_> oerjan: heh, fromList is a painful function to write :(
01:51:42 <elliott_> because just getting a list of chunks isn't enough, i have to all spindly them down into a tree
01:55:02 -!- Lymia has changed nick to Lymee.
01:57:52 <lambdabot> Not in scope: data constructor `Leaf'
01:58:14 <oerjan> > return True :: Tree Bool
01:58:15 <lambdabot> Node {rootLabel = True, subForest = []}
02:01:14 <elliott_> $ time ./nsearch.optim +RTS -N
02:01:15 <oerjan> NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
02:01:23 <elliott_> two seconds later: OMG ITS FOUND
02:02:02 <oerjan> why doesn't it print the initial [, anyway
02:02:29 <elliott_> [undefined] would produce [<exception>
02:02:51 <oerjan> > [undefined] :: [Int]
02:03:01 <oerjan> but even without the brackets
02:03:57 <oerjan> that's the reason why fix show works
02:04:27 <lambdabot> "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\...
02:06:30 <oerjan> > fix (return.var.show) :: [Sym ()]
02:06:31 <lambdabot> [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[...
02:10:19 <oerjan> > fix (return.var.show) :: Maybe (Sym ())
02:10:21 <lambdabot> Just Just Just Just Just Just Just Just Just Just Just Just Just Just Just ...
02:11:00 <oerjan> > Just (Just (Just True))
02:16:05 -!- pikhq_ has joined.
02:16:09 -!- pikhq has quit (Ping timeout: 240 seconds).
02:16:16 <oerjan> elliott_: have you tried timing the parallel one for smaller values? that was some leap from 32 to 34...
02:16:50 <oerjan> how long did that take?
02:19:53 -!- copumpkin has joined.
02:19:53 -!- copumpkin has quit (Changing host).
02:19:53 -!- copumpkin has joined.
02:20:39 <oerjan> <elliott_> realI1m31.738s
02:21:25 -!- copumpkin has quit (Client Quit).
02:21:31 <oerjan> that's more than 100 times up to when you stopped 34 :(
02:21:54 <elliott_> its obviously massively exponential
02:22:32 <oerjan> or rather, i cannot see how it could be _more_ than factorial. well maybe some of the large artithmetic on n.
02:23:22 <ais523> wow, Slashdot has given me a total of 30 moderator points in a week
02:23:36 <oerjan> well you are a very moderate guy
02:24:52 <ais523> according to the FAQ, it implies I'm in the top percentile of moderators, or something like that
02:25:16 <ais523> (moderator selection is random, but apparently when you're selected, you get to do more moderation if the metamoderators think you've been doing well)
02:25:18 <coppro> I mostly read via rss now
02:25:28 <ais523> as far as I can tell, it just means most Slashdotters are really biased
02:25:38 <ais523> and I read Slashdot for the comments
02:26:58 <zzo38> I have sometimes read the comments on Slashdot, too.
02:26:59 <zzo38> Are you able to read pokemon card puzzle by now?
02:27:45 <ais523> I don't understand your notation for energy
02:28:08 <ais523> does @ mean purple/psychic energy?
02:28:57 <zzo38> ais523: What part are you having trouble with about the energy? Yes, @ means purple/psychic energy although you can still solve it without that information (all the card texts use the same notation too, in that file). % means leaf energy (green)
02:28:57 <ais523> also, how many Prizes does each player have? are they called something else?
02:29:10 <zzo38> "Side cards remaining".
02:29:54 <zzo38> Also called Prizes also the name "side cards" is also used sometimes, and that is what I am using there.
02:29:58 <ais523> and numbers on their own in Pokémon descriptions are damages in multiples of 10?
02:30:23 -!- copumpkin has joined.
02:32:30 <zzo38> What is called ten damage is called 1 here; it is more logical.
02:32:32 <ais523> you need to point out that the opponent has at least one card in draw pile
02:32:43 <ais523> otherwise you can win by passing the turn :)
02:32:52 <ais523> you have [irrelevant] there atm
02:36:10 <zzo38> I don't think it is necessary but OK I will change that
02:38:12 -!- zzo38 has quit (Quit: Unfortunately I have to leave now, sorry).
02:40:18 <ais523> I'm not convinced the first puzzle is possible; there seems to be no way to get a draw from the deck other than itemfindering Bill in any of the cards there, and if you do that, you have no way to refill your deck with Nightly Garbage Run
02:40:28 <ais523> other than that, it's reasonably obvious what you have to do
02:41:45 <coppro> ais523: it's not possible according to modern rules
02:42:06 <coppro> it /may/ have been possible according to older rules, although I don't recall them well enough
02:42:20 <coppro> in any case, I'd forgotten the rule that makes it impossible
02:42:21 <ais523> coppro: under zzo38's ruleset, weakness is almost certainly *2 damage rather than a fixed bonus amount of damage like it is nowadays
02:42:56 <ais523> I'm assuming you're meant to hit a weakness (using goop gas attack) in order to deal 60 damage to get one prize, and 10 to a benched to get the other
02:43:30 <ais523> oh, you can just itemfinder for goop gas attack and ignore all the other cards in the discard
02:44:28 <ais523> move a counter from dark muk to porygon, retreat Gengar for Spearow, GoW Dark Muk, retreat Spearow for Hypno, itemfinder for Goop Gas Attack, play it, then hit for 60+10 benched damage for the double KO
02:44:45 <ais523> normally it's bad style to write a puzzle that has that much irrelevant stuff in...
02:46:00 <coppro> ais523: I cannot find any evidence to support your assertion that weakness is not *2 damage nowadays, and that is the correct solution although it's illegal under modern rules as you can only retreat once per turn
02:46:10 <coppro> note that I define 'modern rules' as 'the rulebook on the website'
02:46:15 <ais523> you can only retreat once per turn nowadays?
02:46:19 <ais523> I stopped playing before that was introduced
02:46:33 <ais523> and nowadays, weakness is printed on the cards; it's sometimes *2, but more commonly +20 or +30
02:46:57 <ais523> whereas in the first few sets, weakness was always printed as *2, making it look like a rules reminder rather than actually necessary
02:47:03 <coppro> quick scan shows that most recent expansion is almost always *2
02:48:31 <coppro> although it appears to be relatively simple cards generally
02:48:35 <ais523> hmm, so it's changed again?
02:48:44 <ais523> as I said, I'm a little out of the loop
02:48:53 <ais523> I play the videogames competitively, but not the cards
02:49:13 <ais523> the videogames are much cheaper, a sort of one-off £40 or so for each version, and they come out once every few years
02:49:38 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
02:49:53 <coppro> I suspect that the TCG adopts a similar approach to Magic of making on expansion a year much simpler
02:50:19 <coppro> although it looks like they've been revising the rules a lot too
02:50:25 <ais523> Magic's reason is also because there are a lot of boring cards that are nonetheless necessary to round out decks
02:50:37 <ais523> and yes, I coincidentally quit Magic at the time of the latest big rules change
02:50:59 <ais523> not because of the rules change itself (although I don't really see the point of some of the more controversial changes, and think they're mostly negative), but because I disliked the sets that they'd been making
02:51:25 <coppro> The core sets were never really about printing utility cards
02:51:48 <coppro> They need to be in every set since otherwise the limited format would be impossible to play
02:52:08 <coppro> The new core set model is very awesome
02:52:31 <ais523> but it was the difference between core sets using basic utility cards everyone gets, and expansion sets having quirky ones
02:52:57 <ais523> and often the basic ones were a better fit if you weren't going heavily themed
02:59:14 <coppro> It appears that the Pokemon TCG has redone supporters and stadia again; now they are subtypes of Trainer
02:59:48 <ais523> supporters were always subtypes of trainer, weren't they?
02:59:51 <ais523> just with a 1/turn restriction?
03:00:23 <coppro> except for a while when they were a card type
03:00:42 <coppro> but they were originall cobbled on with annoyingly-present reminder text
03:00:58 <ais523> the reminder text was needed
03:01:07 <coppro> the new Trainer template has room for Item/Supporter/Stadium in the top-right corner and has a nice box at the bottom for the reminder text
03:01:12 <ais523> because people kept trying to bring them to people using only old-style cards, when they first came out
03:01:49 <ais523> the invention of supporters was needed, anyway; under the original rules, there was never a reason not to play 4x Bill and 4x Professor Oak
03:02:10 <coppro> definitely agree there
03:02:43 <ais523> (bill was completly safe, professor oak was a gamble but one that had incredibly good return)
03:02:47 <coppro> there's now also basic metal and dark energy, but without the special effects
03:02:53 <ais523> that was needed too, I think
03:03:02 <coppro> Just wait until your hand is low, then play Oak
03:03:14 <ais523> coppro: I mean, you might draw Oak at a time when it isn't useful
03:03:23 <ais523> worst case is getting two Oaks from Bill
03:03:34 <coppro> but then you just play one and the problem goes away
03:03:46 <ais523> yep, it's just a waste more than anything else
03:03:50 <ais523> it's a very good worst case :)
03:09:11 -!- copumpkin has joined.
03:09:11 -!- copumpkin has quit (Changing host).
03:09:11 -!- copumpkin has joined.
03:21:33 -!- jcp|1 has joined.
03:21:54 -!- jcp has quit (Ping timeout: 258 seconds).
03:23:28 -!- jcp|other has quit (Ping timeout: 255 seconds).
03:27:19 -!- jcp|other has joined.
03:29:25 -!- jcp|1 has quit (Ping timeout: 264 seconds).
03:29:27 -!- TeruFSX has quit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.).
03:29:34 -!- jcp has joined.
03:29:41 -!- BeholdMyGlory has quit (Remote host closed the connection).
03:38:08 -!- pikhq has joined.
03:41:10 -!- pikhq_ has quit (Ping timeout: 244 seconds).
03:41:51 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
03:53:39 -!- quintopia has quit (Ping timeout: 250 seconds).
03:55:38 -!- jcp|1 has joined.
03:56:19 -!- jcp has quit (Ping timeout: 255 seconds).
03:56:58 -!- jcp|other has quit (Ping timeout: 258 seconds).
03:58:58 -!- zzo38 has joined.
03:59:35 -!- quintopia has joined.
03:59:41 <zzo38> If it says "irrelevant" it means those cards are not important for the puzzle.
04:00:03 <zzo38> ais523: Did you figure it out?
04:03:32 <ais523> <ais523> move a counter from dark muk to porygon, retreat Gengar for Spearow, GoW Dark Muk, retreat Spearow for Hypno, itemfinder for Goop Gas Attack, play it, then hit for 60+10 benched damage for the double KO
04:04:02 <ais523> there were a lot of things shown in that puzzle that weren't necessary, though
04:04:05 -!- jcp has joined.
04:04:10 <ais523> as in, you only need to involve half the things on the field
04:30:51 <coppro> I'd say card game puzzles should not include irrelevant game state
04:31:34 <elliott_> purely functional card g- oh wait that's this year's ICFP
04:35:13 <monqy> doesn't that game have so much state
04:35:24 <elliott_> but it's manipulated with pure functions
04:37:30 -!- myndzi\ has quit.
04:55:16 -!- hagb[4]rd has quit (Ping timeout: 255 seconds).
05:24:57 <zzo38> I included some irrelevant thing I think it should sometimes contain some. Even in chess puzzle they sometimes do. But in tsume shogi they usually do not contain irrelevant things.
05:25:19 -!- myndzi has joined.
05:25:56 <elliott_> hmm, I was going to code something
05:26:00 <elliott_> ah, probably a nice esointerpreter
05:26:05 <zzo38> ais523: You did it good. Now try second one too.
05:26:28 <elliott_> oh, but then suddenly most esolangs are bad? :(
05:27:01 <zzo38> elliott_: Please do code something. Code everything.
05:27:10 * pikhq wonders how easy would it be to get GHC working with musl.
05:27:10 <elliott_> there would be nothing left to not code.
05:27:19 <elliott_> pikhq: it works on windows, so ... trivial?
05:27:30 <zzo38> ais523: Do you know how to make up another pokemon card puzzle, too? I would like to see.
05:27:33 <monqy> is zepto good is zepto esolangs
05:27:37 <monqy> is zepto interpreter
05:27:39 <elliott_> monqy: zepto is so fucking good, you have no idea.
05:27:51 <elliott_> im crying over how good zepto is.
05:27:57 <elliott_> this is the saddest day of my life.
05:27:58 <pikhq> elliott_: Okay, then it'd more just be the pain of building it at all.
05:28:12 <monqy> ill never be as good as zepto
05:28:35 <elliott_> http://killyourself.org/ "killyourself.org - All about the Consideration to Kill Yourself"
05:28:38 <pikhq> zzo38: zepto is that property which most software lacks.
05:28:41 <elliott_> "in suck as hell..!!!!! kill your self if u play like this..!"
05:29:21 <zzo38> Zepto- (symbol z) is a prefix in the metric system
05:29:36 <elliott_> HOW TO KILL YOUR SELF ON BIG DIRT BIKE
05:29:36 <elliott_> THE MAD SAILORS HAVE CHANGED FROM WATER TO WHEELS. WHAT NEXT
05:30:09 <elliott_> Just came accross the following post on care2.com – Female Veterans More Likely To Commit Suicide and wanted to share it here with you on killyourself.org ...
05:30:23 <elliott_> zzo38: it's also an adjective, and also an adverb
05:30:32 <elliott_> oh it is also a verb and a noun
05:30:43 <elliott_> i zepto zepto with my zepto zepto. it was zepto.
05:30:55 <elliott_> it can also replace other words if you want e.g.
05:31:05 <elliott_> zepto zepto zepto zepto zepto zepto zepto. it zepto zepto.
05:31:41 <oerjan> there is no true or false. there is only zepto
05:31:55 <elliott_> the boolean type in zepto has one value
05:32:31 <oerjan> "One zeptomole (zmol) of substance contains 602 particles."
05:32:59 <elliott_> yes. this is why integers literals in zepto are base 602
05:33:42 <elliott_> but do i do it in C or Haskell
05:33:45 <elliott_> obviously Final Zepto must be in C
05:33:49 <elliott_> but this it not Final Zepto, oh no
05:33:58 <oerjan> no, final zepto must be in zepto, duh
05:34:06 <elliott_> this is but a meandering zepto on the zepto path to the one true zepto zepto which zepto zepto, and thus becometh the final zepto.
05:34:11 <zzo38> Now I am confused of it.
05:34:22 <elliott_> zzo38: me too. tip: try and not understand it and instead zepto.
05:34:29 <elliott_> oerjan: ah. you would think. but a failed bootstrapping is not very zepto.
05:34:43 <elliott_> and if you lose the binary, as zepto people are wont to do, then that would make it a very un-zepto situation.
05:34:55 <elliott_> also, compilers are un-zepto, so that's just too recursive for the universe to handle.
05:35:02 <monqy> zepto in haskell, then make a zepto program to generate the final zepto
05:35:02 <elliott_> although that, in itself, is very zepto, we are unfortunately constrained.
05:35:05 <zzo38> elliott: OK. But are you going to write in esolang wiki or what else? How can you do?
05:35:08 <elliott_> we can only achieve universal zepto.
05:35:14 <elliott_> zzo38: i think it might get deleted as spam :D
05:35:51 <oerjan> elliott_: well there's only one final solution then, we must ki^W implement hardware zepto.
05:36:05 <zzo38> Then post it in your own computer
05:36:39 <elliott_> oerjan: yes we must ki^W implement it.
05:36:40 <pikhq> Thou shalt not ignore CC
05:36:48 <pikhq> Thou shalt not override CC.
05:37:07 <zzo38> Zepto is the property most software lacks. Then should you say all software lacks it?
05:37:08 <pikhq> I shall feel compelled to beat you.
05:38:18 <pikhq> It is using autoconf and somehow making it ignore CC.
05:38:33 <pikhq> That is impressive and I feel compelled to murder those responsible.
05:39:01 <elliott_> In fact if you have zepto on your system, there is very little reason not to just delete all the other software on it.
05:40:20 <zzo38> elliott_: Same thing.
05:41:40 <zzo38> elliott_: As to zepto.
05:42:26 -!- Sgeo_ has joined.
05:42:50 <zzo38> Can you make up any new pokemon card puzzles? I would like to see it, too.
05:42:55 <pikhq> coppro: It seems that most compilers supporting normal, cross, and Canadian cross builds using autoconf fuck it up.
05:43:17 <oerjan> pikhq: maybe it's a leftover from the evil mangler age
05:43:31 <pikhq> PCC and CINTERCAL are the only ones that seem to do it right that I know of.
05:43:41 <pikhq> (TCC also does it right, but it doesn't use autoconf.)
05:44:20 <pikhq> ghc-cabal: Bad header file: HsBase.h
05:44:20 <pikhq> The header file contains a compile error. You can re-run configure with the
05:44:20 <pikhq> verbosity flag -v3 to see the error messages from the C compiler.
05:44:31 <pikhq> I... Blimble... What the... Fuuuck?
05:44:46 -!- Sgeo has quit (Ping timeout: 255 seconds).
05:45:39 -!- elliott_ has quit (Read error: Connection reset by peer).
05:45:51 -!- elliott has joined.
05:45:59 <elliott> monqy: would you like the greatest privilege
05:46:20 * pikhq sees if that fails without --with-gcc=musl-gcc...
05:46:41 <pikhq> If not, then I suppose I'll have to bother building a proper cross compiler.
05:46:49 <elliott> monqy: you could have a part in the designing of the initial zepto revision/derivative/variant/exoskeleton, ante-zepto
05:46:54 <pikhq> Aside from PCC, that is.
05:47:50 <elliott> monqy: moral support. also, implementation details.
05:48:18 <oerjan> you may also have to provide a few inessential vital organs.
05:48:59 <elliott> monqy: also you get to supply bignum algorithms that i'm too lazy to write, or maybe i could just be really really un-zepto
05:49:11 <elliott> yes, that means that + would fail for no reason and you would have to be all oh :(
05:49:19 <monqy> whats bignums whats algorithms
05:49:35 <pikhq> Strange, it seems to be missing some Haskell dependencies.
05:49:41 <pikhq> I have the effing Platform.
05:49:53 <elliott> haskell platform: literally contains every haskell library
05:49:55 <monqy> somehow i've never learned how to implement bignums
05:50:21 <elliott> what other types do we need monqy
05:50:33 <pikhq> Hmm, it actually doesn't have readline.
05:50:49 <monqy> padic is not four letters
05:51:31 <elliott> p-adic numbers are nice they make me smile
05:52:17 <monqy> are characters zepto so long as there is no worry about messy things like encoding
05:52:39 <elliott> monqy: you just use symbols
05:52:46 <elliott> symbols are words, strings are words, what is the difference
05:52:57 <monqy> i guess this works
05:53:00 <elliott> i GUESS there can be a function to get the nth codepoint in a symbol as an integer
05:53:19 <elliott> anyway we don't need non-primitive functions of course
05:53:28 <elliott> we just define the application of e.g. ((x) x) instead
05:55:55 <elliott> monqy: oh yeah previously zepto was dynamically scoped but I guess it can be lexical now???
05:56:27 <monqy> all i remember about zepto is i had no idea what was going on
05:57:13 <elliott> (def lambda '(e fn '(e* arr . (apply e fn (eval arr e*)))))
05:57:40 <elliott> pikhq: oh right jhc requires a haskell compiler
05:58:46 <pikhq> Y'know what? Haskell is insufficiently sane. :P
05:59:23 <pikhq> Thus far, there has been only one language implementation that has "just worked" with musl.
05:59:41 <pikhq> ./configure&&make&&make install
06:00:13 <pikhq> ... Of course, this is a language that only recently dropped its support for the PocketPC and the Palm Pilot.
06:01:01 <monqy> are any languages sufficiently sane
06:01:06 <pikhq> monqy: Not really.
06:01:33 <monqy> my experience as well; I was hoping for a different answer :(
06:01:41 <pikhq> Okay, well, I suppose that PCC was relatively sane...
06:01:53 <pikhq> Only had to futz with config.sub and the path to the dynamic linker.
06:02:12 <pikhq> elliott: Guess what doesn't work?
06:02:26 <pikhq> It seems to be assuming glibc overincluding.
06:02:41 <elliott> monqy: hmm oh quote is not the same thing as lambda if I make things lexically scoped
06:02:54 <pikhq> ... I... And... Defuck?
06:03:27 <elliott> we need a vau s.t. (vau args . fn) in environment e === (cons (cons e args) fn)
06:03:28 <oerjan> no defuck. or phantom_hoover will massacre you.
06:03:54 <elliott> (vau x . x) ==> ((<environment> . x) . x)
06:03:55 <pikhq> IT'S TIME.H NOT SYS/TIME.H
06:03:59 <oerjan> elliott: wait are you basing this on that vau idea?
06:04:00 <elliott> where <environment> is an environment object
06:04:14 <elliott> oerjan: well yes, it is basically fexpr construction
06:04:25 <elliott> oerjan: and if one represents lambdas as lists, and wants lexical scoping, then you need to include the environment in
06:04:32 <elliott> so vau basically becomes a convenience
06:05:10 <elliott> it needs to take the environment as an operator too
06:05:36 <elliott> (vau env args . fn) in environment e === (list e env args . fn)
06:06:07 <elliott> (vau e x (eval e x)) ==> (<environment> e x (eval e x))
06:06:23 <elliott> monqy: this is becoming unzepto :(
06:07:51 <elliott> monqy: i guess we could go dynamically scoped again
06:08:35 <monqy> how does dynamic scoping work with things like not feeling messy
06:08:37 <newsham> it worked out so well the first time
06:08:40 <monqy> I've never really studied it
06:09:34 <elliott> monqy: its great exclamation marks
06:09:41 <elliott> here's a schemeish example
06:09:52 <elliott> (define (g) (let ((x 0)) (f)))
06:10:08 <elliott> sorry for momentarily misleading you into thinking that dynamic scoping was sane in any way
06:10:31 <newsham> if you wanna relive bad programming decisions, just use perl
06:10:36 <zzo38> How much do you know of the Lesser Key?
06:10:49 <monqy> is there a perl lisp
06:11:42 <monqy> perl of lisps, perl with lisp syntax and benefits thereof, others???
06:11:46 <newsham> ". Perl is another language with dynamic scoping that added static scoping afterwards"
06:12:09 <monqy> is php dynamically scoped or did they fix that or was I dreadfully misinformed
06:19:40 <Nisstyre> monqy: php has no dynamic scoping
06:20:15 <monqy> grats masterful php designers
06:22:03 <oerjan> > let ?x = 9; f = x; g = let ?x=0 in f in g
06:22:03 <lambdabot> <no location info>: parse error on input `f'
06:22:19 <oerjan> :t let ?x = 9; f = x; g = let ?x=0 in f in g
06:22:30 <elliott> monqy: oh cool my environments are immutable :slowpoke:
06:23:04 <elliott> monqy: i failed to make them mutable, this is haskell
06:23:09 <elliott> should conses be immutable y or n
06:23:28 <elliott> bear in mind that if conses are immutable, there is exactly one kind of mutable object, environments
06:23:31 <oerjan> > let {?x = 9; f = x; g = let {?x=0} in f} in g
06:23:32 <lambdabot> <no location info>: parse error on input `f'
06:23:53 <oerjan> > let {?x = 9; f = x; module g = let {?x=0} in f} in g
06:23:53 <lambdabot> <no location info>: parse error on input `f'
06:24:13 <monqy> there would still be a way to define cyclic things right
06:24:54 <oerjan> > let {?x = 9; f = ?x; module g = let {?x=0} in f} in g
06:24:54 <lambdabot> <no location info>: parse error on input `f'
06:25:02 <monqy> cycles are my bro but so is immutability
06:25:34 <oerjan> > let {?x = 9; f = ?x} in f
06:25:35 <lambdabot> <no location info>: parse error on input `f'
06:26:12 <oerjan> > let {?x = 9; g = ?x} in f
06:26:13 <lambdabot> <no location info>: parse error on input `g'
06:26:58 <oerjan> > let ?x = 9 in let f = ?x; g = (let ?x = 0 in f) in g
06:28:05 <oerjan> > let ?x = 9; ?y = 2 in let f = ?x; g = (let ?x = 0 in f) in g + ?y
06:28:29 <oerjan> hm is it forbidden to let both ? variables and others in the same block?
06:31:17 <lambdabot> forall a1 r (m :: * -> *). (Monad m) => (a1 -> r) -> m a1 -> m r
06:31:28 <elliott> ?hoogle (a -> b -> m c) -> m a -> m b -> m c
06:31:29 <lambdabot> Control.Monad zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
06:31:29 <lambdabot> Control.Monad zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
06:31:29 <lambdabot> Control.Monad foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
06:31:35 <elliott> ?hoogle (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Prelude (=<<) :: Monad m => (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Control.Monad (=<<) :: Monad m => (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Prelude (>>=) :: Monad m => m a -> (a -> m b) -> m b
06:33:12 <oerjan> :t \f x y -> (f <$> x) =<< y
06:33:13 <lambdabot> forall a (m :: * -> *) b a1. (Monad m) => (a -> m b) -> (a1 -> a) -> m a1 -> m b
06:33:49 <oerjan> :t \f x y -> (f <$> x <$> y)
06:33:49 <lambdabot> forall a b a1 (f :: * -> *). (Functor f) => (a -> b) -> (a1 -> a) -> f a1 -> f b
06:34:33 <oerjan> :t \f x y -> (f <$> x) <*> y
06:34:34 <lambdabot> forall a a1 b (f :: * -> *). (Applicative f) => (a -> a1 -> b) -> f a -> f a1 -> f b
06:34:57 <oerjan> :t \f x y -> join (f <$> x <*> y)
06:34:58 <lambdabot> forall a a1 (m :: * -> *) a2. (Applicative m, Monad m) => (a -> a1 -> m a2) -> m a -> m a1 -> m a2
06:35:33 <Deewiant> ?ty \f ma mb -> ma >>= \a -> mb >>= \b -> f a b
06:35:34 <lambdabot> forall (m :: * -> *) a a1 b. (Monad m) => (a -> a1 -> m b) -> m a -> m a1 -> m b
06:35:52 <Deewiant> For your non-Applicative Monad needs
06:36:11 <elliott> Deewiant: Such monads don't exist
06:36:25 <oerjan> ?pl \f ma mb -> ma >>= \a -> mb >>= \b -> f a b
06:36:25 <lambdabot> flip ((.) . (>>=)) . flip ((.) . (>>=))
06:36:34 <elliott> Deewiant: There are no monads that are not applicative functors
06:36:44 <oerjan> ?pl ma >>= \a -> mb >>= \b -> f a b
06:36:45 <Deewiant> elliott: The instance might not be defined
06:37:02 <elliott> Deewiant: instance Applicative M where pure = return; (<*>) = ap
06:37:17 <elliott> Better three lines than writing ugly code for the sake of a lie
06:37:19 <Deewiant> elliott: An extra line of code, and potentially inefficient
06:37:40 <elliott> Got any benchmarks for applicative code being slow? :-P
06:38:19 <Deewiant> I didn't mean the applicative-ness of it, just that defining <*> via a helper like ap might end up doing unnecessary work
06:38:55 <lambdabot> (\ d e -> d >>= \ b -> e >>= \ a -> return (b a))
06:39:17 <elliott> Deewiant: instance Applicative M where pure = return; f <*> x = f >>= \f' -> x >>= \x' -> return (f' x'), if you're into ugliness
06:39:53 <fizzie> What a best ending for a vacation. They're doing a bathroom renovation thing in the apartment downstairs from us; we walk in with suitcases and so on, and the people doing it go: "Hey, do you live in the apartment above?" Sure, why? "We just accidentally drilled into your sewer and now you can't use your bathroom until it's fixed."
06:39:55 <elliott> Deewiant: Have I mentioned that my hypothetical GHC extension would make this unnecessary?
06:39:57 <lambdabot> class Functor f => Applicative f where
06:40:17 <elliott> instance Applicative M where
06:40:17 <elliott> f <*> x = do f' <- f; x' <- x; return (f' x')
06:40:32 <elliott> Deewiant: What I'm saying is: Woo, GHC extensions that don't yet actually exist
06:41:11 <elliott> Deewiant: You were meant to ask what it is, but fine, ruin my flow like that
06:42:46 <monqy> wait why not (<*>) = ap
06:43:30 <zzo38> Someone told me that MISSINGNO actually has four attacks: FIREBALL, ICEBALL, THUNDERBALL, and SUPERBALL. The SUPERBALL attack does no damage but makes the screen look like a pinball game. However, I do not believe any of this is true.
06:43:32 <monqy> I read that gentoo is for ricers thing yesterday and it was amazing. this reminds me of that.
06:43:45 <elliott> Deewiant: ASK ME WHAT THE EXTENSION IS
06:44:17 <pikhq> zzo38: Strange, considering that none of those attacks exist in the game.
06:44:54 <zzo38> pikhq: Yes, I know.
06:45:12 <coppro> yeah, that site is awesome
06:45:24 <coppro> elliott: you know of funroll-loops.info, right?
06:45:58 <elliott> elliott@katia:~/logs$ grep -r funroll-loops\.info ????-??-??.txt | grep 'tusho\|ehird\|elliott\|alise'
06:45:58 <elliott> 2008-06-23.txt:18:18:25: <tusho> ais523: http://funroll-loops.info/
06:45:58 <elliott> 2009-01-07.txt:15:55:01: <ehird> I am so tempted to link to http://funroll-loops.info/ here. Oh wait I just did
06:46:02 <elliott> I swear I've linked it a lot more than that
06:46:20 <coppro> my favorite line there is "If the reviewers had been serious they would have used an optimised distributions such as Gentoo, which would have taken far fuller advantage of the extra 32bits in each register to provide a much fuller experience, more than any current Linux distribution possibly could."
06:46:28 <elliott> Man, I wonder how long that site has just been up unchanged
06:46:49 <elliott> coppro: This is the best one, IMO: "I don't think that Debian can really compete with Gentoo. Sure it might be okay, but when it comes to dependencies, you probably are still going to have to get them all on your own. Or is there something like portage in the Debian world as well?"
06:46:52 <monqy> too much of it is my favorite
06:47:02 <monqy> that one's one of them
06:47:42 <Deewiant> 2009-10-31 02:59:02( ehiird) "I don't think that Debian can really compete with Gentoo. Sure it might be okay, but when it comes to dependencies, you probably are still going to have to get them all on your own. Or is there something like portage in the Debian world as well?" -- funroll-loops.info
06:48:01 <elliott> Deewiant: Huh, clog incompleteness?
06:48:07 <Deewiant> 2011-01-27 00:42:41( elliott) Vorpal: from a thread about funroll-loops.org on the Gentoo forums, circa 2004: "One week later: this is on the Arch forums. One month later: the Arch people get the joke."
06:48:16 <elliott> Fuck it, I need a database of my nicknames
06:48:25 <Deewiant> 2011-07-02 00:21:53( elliott) oblig. http://funroll-loops.info/
06:48:33 <elliott> Yes but that was what caused monqy to read it.
06:48:35 <elliott> SO THAT DOESN'T EVEN COUNT
06:49:32 <ais523> [Tuesday, November 30, 2010] [04:07:07 pm] <elliott>Phantom_Hoover: We're talking -O3 -funsafe-math -fomit-function-pointer -funroll-loops -fadvanced-maths -fcrazy-maths -fyour-mother-and-a-horse -fit-never-happened -flanguid-squids ...
06:49:46 <elliott> I still use -flanguid-squids in all my programs
06:49:49 <ais523> not a direct reference, though
06:50:01 <Deewiant> I searched for "funroll-loops."
06:50:06 <ais523> I just searched for funroll
06:50:13 <ais523> in my own personal logs
06:50:23 <elliott> Also -fit-never-happened; it lets you detect _|_ values without resulting in _|_ (impossible with any other method), and optimises all computations to run in 0 ms
06:51:05 -!- augur has quit (Remote host closed the connection).
06:51:16 <zzo38> What are _|_ values?
06:52:08 <zzo38> Are you allergic to bullets?
06:52:08 <elliott> zzo38: any failing/non-halting computation, e.g. infinite loops and errors
06:52:15 <oerjan> > let (_|_) = undefined in (_|_)
06:52:16 <lambdabot> <no location info>: parse error on input `|'
06:52:21 -!- augur has joined.
06:52:29 <elliott> oerjan: you can do it with the unicode bottom symbol
06:52:34 <elliott> it still needs to be an operator though :(
06:53:21 <oerjan> > let _I_ = undefined in _I_
06:53:26 <coppro> 'void' in C is actually bottom as well
06:53:36 <coppro> although 'void*' is not a pointer to bottom
06:53:45 <elliott> you can return from a function that returns void
06:53:48 <elliott> void is not really one type in C
06:53:54 <elliott> as a return type, it signifies the unit type
06:54:01 <elliott> it is not a valid variable type
06:54:16 <coppro> of course it isn't a variable must have a value
06:54:18 <elliott> but as a pointed-to type, it's... it's (void *)
06:54:41 <monqy> (void *) is spooky
06:54:47 <elliott> coppro: you are confused. if void was the type _|_, then no function declared as "void f();" would ever be able to return
06:55:07 <elliott> it is instead the _unit_ type as a function return type, e.g. ()
06:55:08 <zzo38> LLVM also has 'void' type, but not 'void*' type. But it also has nonreturning type which is separate.
06:56:22 <elliott> monqy: (eof? getc putc close) -- List of functions: BEST INTERFACE?
06:57:44 <monqy> what good is close without open
06:58:12 <elliott> monqy: open is how you get that list duh
06:58:18 <elliott> a handle is literally represented as the functions operating on it
06:58:19 <zzo38> If it is existing object, then open gives you the object.
06:58:24 <elliott> stdin is (<function> <function> <function> <function>)
06:58:57 <coppro> elliott: I actually really like that model
06:59:13 <monqy> well at least I think I like it
06:59:46 <Deewiant> elliott: Now if it were opaque and thus type-safe
06:59:52 <newsham> void * is the opposite of bottom
06:59:55 <monqy> so is this a quadruple or a list
07:00:50 <elliott> coppro: Well, sure, it's BASICALLY a record of functions
07:01:02 <elliott> coppro: It's just that having it as an arbitrarily ordered list with no names or anything is dumb dumb dumb :P
07:01:07 <elliott> I could use an ENVIRONMENT
07:01:17 <elliott> It's basically a dictionary type
07:01:21 <monqy> first-class environments?
07:01:21 <elliott> Except you could merge it in with your environment
07:01:27 <elliott> And thus get a global "current stream"
07:01:30 <coppro> elliott: OR EVEN BETTER, YOU COULD CREATE A POLYMORPHIC... WAIT NO THAT'S OBJECT-ORIENTED
07:01:37 <elliott> Oh man, that is so the best, objects as literal scopes.
07:01:43 <elliott> I am a genius. This is the most zepto thing ever.
07:04:18 <elliott> coppro: No, it's way better than that.
07:04:38 <pikhq> -af scaletempo -speed 3
07:04:41 <monqy> proof: zepto is zepto. perl isnt. qed.
07:04:43 <pikhq> The solution to RPG TASes.
07:04:44 <elliott> coppro: Every function can look at the environment it gets called in, right? So environments are first-class. So you can poke around looking at various variables in your environment, enumerating them, blah blah blah.
07:05:04 <elliott> coppro: So if we represent, e.g. a file as an environment with _only_ the bindings get-char, put-char, eof?, etc.,
07:05:11 <elliott> coppro: Then we can read these in and call them,
07:05:14 <elliott> coppro: Modify them (with set),
07:05:19 <elliott> coppro: And even bring them into scope:
07:05:32 <elliott> coppro: (with-env stdin (put-char 'c'))
07:05:50 <elliott> coppro: So this means that we can have an implicit "current default output stream" without even doing anything!
07:06:01 <elliott> And it is basically equivalent to an object as a hash table.
07:06:25 <coppro> elliott: I want you to write me up a formal specification so that I can present this at a conference
07:06:59 <elliott> coppro: YOUR SARCASM MAY STING BUT MY GENIUS WILL SHINE THROUGH WHEN I AM DEAD
07:07:07 <elliott> Or maybe it isn't sarcasm and you just really like frightening people :P
07:07:39 <elliott> First-Class Environments as Objects: or, Let: The Ultimate Overloader
07:08:12 <monqy> turn it into a paradigm
07:08:35 <elliott> I just want you all to know that I literally just got up and did a ridiculous dance around the room while waving my hands and doing the most insane cackle I could muster at the same time.
07:08:44 <elliott> FEAR ME, PROGRAMMING WORLD
07:08:47 <oerjan> get crushed when oleg points out it's just simple syntactic sugar over delimited continuations
07:09:30 <oerjan> then continue to sell books as no one outside #haskell understands oleg
07:09:59 <elliott> coppro: oh, it's even better; you can make mutations of object members work with plain "set" just by making the object itself the top-level environment of all the functions inside
07:11:11 <elliott> hmm the with-env thing doesn't /quite/ work since environments are based on _static_ scope, i.e. a piece of code's default handle is based on the context around it, rather than dynamic scope... but I'm sure I can fix that
07:11:17 <elliott> oh, it's just dynamic variables, except I want a dynamic /added scope/
07:11:29 <elliott> that sounds perfectly reasonable and logical, now I just have to figure out what it even _means_
07:11:46 <monqy> then turn it into papers, books
07:11:54 <elliott> monqy: the whole world is exploding into little ribbons of zepto
07:11:59 <elliott> i'm going to take some zepto in celebration
07:12:49 <coppro> elliott: and infinitely recursive functions can be used to make changes 'permanent'
07:13:24 <coppro> elliott: Use the Erlang model of events
07:13:45 <coppro> every handler ends with a tail recursive call
07:13:55 <coppro> so that you have a 'loop'
07:14:31 <elliott> i think you have invented another model that's just as crazy :D
07:18:43 <zzo38> "noreturn" is a function attribute and not a type in LLVM, although it could work even if it was a type (because if it doesn't return, it shouldn't be necessary to specify another return type anyways)
07:18:46 <elliott> Loading package array-0.3.0.2 ... linking ... done.
07:18:46 <elliott> Loading package containers-0.4.0.0 ... linking ... done.
07:18:46 <elliott> *Main> code <- anteList [AnteSymbol "eval", AnteEnv env, AnteSymbol "eval"]
07:18:46 <elliott> *** Exception: AnteException <AnteValue>
07:19:48 <monqy> what just happened
07:19:54 <elliott> monqy: something went wrong in the evaluation
07:20:11 <oerjan> something unAnteCipated
07:20:15 <elliott> monqy: dunno, I can't display values yet
07:22:09 <coppro> elliott: No, it's your regular event loop in functional programming
07:22:46 <coppro> you make a change of "state" by calling back into the event loop with a different argument
07:22:54 <coppro> but if the "state" is the scope...
07:23:22 <monqy> what happens if you call somewhere that isn't (directly) back into the event loop
07:23:36 <coppro> then the loop terminates
07:26:19 <elliott> Error: (bad-function eval)
07:26:41 <elliott> Error: (bad-function #<environment>)
07:27:54 <elliott> monqy: what if i removed cons pairs
07:27:57 <elliott> what if i replaced cons pairs
07:28:03 <elliott> just containing the keys "car" and "cdr"
07:29:21 <elliott> monqy: and then instead of a meaningless list a function could be
07:29:33 <coppro> elliott: I have no ability to compensate for the presence of zepto
07:29:51 <elliott> #{env: ...; envName: 'e; argName: 'x; code: ...}
07:31:02 <monqy> instead of function application you have some weird sort of environment mangling (of which function application is a special case)
07:31:20 <monqy> where by special case I mean
07:31:25 <monqy> not special at all
07:31:32 <monqy> unless you sugar it up
07:31:34 <elliott> monqy: im starting to feel like this might not be lisp any more at all
07:31:45 <coppro> elliott: it's not in kansas either
07:31:46 <monqy> one time I had a language idea sort of like this. I forget what happened to it.
07:32:05 <elliott> i think im going to be a wimp for now and keep cons cells being, you know, still a thing that exist
07:32:17 <elliott> but I might change functions into environments rather than a meaningless list
07:32:33 <elliott> it is tempting to make applying an environment to an argument look that argument up in the environment
07:34:17 <coppro> we should call this language "greenparty"
07:34:45 <monqy> yes that was part of my dead language i think. and all functions were environments with rewrite rules or something else special like that.
07:34:53 <monqy> it was a few years ago so the details are very hazy
07:35:12 <elliott> coppro: im sorry, its called zepto
07:35:22 <elliott> any language that has the zepto nature should, by rights, be called zepto
07:35:26 <elliott> although it can have another name, too
07:35:30 <elliott> it could be called greenparty-zepto
07:35:54 <elliott> no, finding the zepto languages must be a painless (zepto) process for the programmer
07:36:07 <elliott> so it must always be clearly delineated from the other name
07:36:16 <elliott> it is ok. we all sometimes zepto-fail.
07:36:26 <elliott> in fact, that which is zepto is not zepto without zepto-fail.
07:36:38 <coppro> is it wrong to mount things directly onto /media or /mnt?
07:36:41 <elliott> the very definition of zepto may even be learning to accept zepto-failing in your heart.
07:36:48 <elliott> coppro: mounting into /mnt is done by the debian-installer
07:36:58 <elliott> I think doing it in /media is totally unacceptable
07:37:00 <elliott> coppro: what do you mean then
07:37:07 <elliott> debian-installer mounts the target system as /mnt
07:37:07 <coppro> elliott: I plug a usb drive in
07:37:15 <coppro> sudo mount /dev/sdb1 /media
07:37:28 <elliott> yeah that's no good make a directory you bum
07:38:40 <elliott> monqy: ok so im not sure what this bug is so im considering just calling it a feature?
07:38:44 <elliott> application being broken is a feature
07:38:56 <elliott> maybe i should sleep, sleep would be unzepto because zepto is to be optimised for sleep-deprived zepto programmers
07:38:59 <monqy> whats wrong with ap;plication
07:39:04 <elliott> and that requires an unzepto frame of mind
07:39:07 <elliott> monqy: i dunno you tell me
07:42:07 <monqy> too cool to derive Show
07:42:40 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
07:43:04 <elliott> monqy: whats that supposed to mean
07:43:09 <elliott> monqy: i lit. can't derive show
07:43:28 <elliott> monqy: im thinking about making zepto stm
07:43:54 <elliott> monqy: http://sprunge.us/HWMi
07:44:03 <elliott> this is ante-zepto initial
07:45:34 <Deewiant> instance Show a => Show (IORef a) where showsPrec d r = showParen (d>10) $ showString "unsafePerformIO (newIORef " . showsPrec 11 $ unsafePerformIO (readIORef r)
07:45:50 <monqy> this makes me uncomfortable
07:46:09 <elliott> Deewiant: please...stop existing...
07:46:19 <elliott> im really not happy that you exist
07:46:20 <Deewiant> I forgot to add the ")" at the end
07:49:28 <elliott> monqy: the world is becoming unzepto i need another breakthrough like environment objects
07:49:53 <monqy> im tired this may or may not help
07:50:13 <elliott> monqy: im sleep deprived how can you possibly imrpove on that
07:50:34 <monqy> this is the best i can do
07:51:26 <elliott> monqy: btw did you note how i cunningly avoided so many unzepto feelings by not using a monad stack
07:51:49 <elliott> i understand its quite hard to read code when its not all in nice rainbow colours in your editor, this is why pastebin sites are the devil
07:51:56 <monqy> i avoid monad stacks too
07:52:12 <monqy> if it means what i think it means
07:53:11 <elliott> monqy: things that look like BlahT (BluhT (BlingT IO)))
07:53:30 <elliott> http://sebfisch.github.com/haskell-regexp/regexp-play.pdf this is a nice paper it has a bunch of people talking who are nice people and, also, the code is all in nice colours and also it has nice fancy symbols
07:53:31 <monqy> juggling lifts makes me uncomfortable
07:53:40 <elliott> i recommend it to every sleep-deprived haskell programmer it is making me happy
07:53:47 <elliott> monqy: well that's kind of what the various typeclasses are for
07:53:57 <monqy> I guess those help yes
07:54:09 <elliott> Using sym, we can translate every regular expression into a
07:54:09 <elliott> weighted regular expression in a canonical fashion:
07:54:55 <monqy> when im tired my eyes skip around and it's hard to read
07:55:08 <monqy> wow is this paper a play
07:55:20 <olsner> weighted regexps? sounds heavy.
07:56:24 <elliott> monqy: i suggest zooming in by the way, zooming in is nice because everything gets bigger
07:56:43 <monqy> less room for my eyes to skip
07:58:23 <elliott> Cody means a sequence of n copies of x
07:58:39 <elliott> i really like how everyone understands each other in this
07:59:08 <monqy> i want to see this acted out
07:59:22 <elliott> i want to voice act it now
08:04:04 <pikhq> Welp, that was fun. And absurd.
08:04:09 <pikhq> 151 mon run of Pokemon.
08:04:28 <pikhq> 3:20, only tolerable at ~3x speed.
08:04:37 <pikhq> Utterly ridiculous.
08:04:46 <elliott> HAZEL I told you about Google’s new library. They implemented
08:04:46 <elliott> an algorithm in C++ with similar worst case performance as our
08:04:46 <elliott> algorithm. Do you know any C++?
08:06:11 <elliott> monqy: hey is it just me or is ungetc an unzepto kind of function
08:06:20 <pikhq> Actually, a 152 mon run, really; shame Missingno doesn't count on the Pokédex in-game.
08:06:25 <pikhq> elliott: Utterly unzepto.
08:06:54 <elliott> monqy: you can put the character you just read back into a stream
08:06:57 <elliott> so it will be read again next time
08:06:59 <elliott> but its only one character
08:07:03 <elliott> constant size buffer of one
08:07:03 <monqy> i meant what in the sense that
08:07:46 * pikhq wonders how that is usually implemented
08:07:50 <elliott> -- A handle has the keys: (foo) means only foo type handles
08:07:53 <elliott> DO I NEED ANYTHING ELSE PIKHQ
08:07:57 <elliott> also, usually implemented: char keep;
08:08:04 <elliott> negative one if theres nothing to buffer
08:08:14 <elliott> or it just integrates into the regular buffer i guess
08:08:19 <elliott> with some special code to break it if you call it more than once
08:08:39 -!- Phantom_Hoover has joined.
08:08:46 <elliott> SCENE I. INFINITE REGULAR EXPRESSIONS
08:08:58 <pikhq> Hmm. Well, musl appears to just directly write it into the read buffer.
08:09:14 <elliott> THEO I like our work as well, although it is always difficult to work
08:09:14 <elliott> with practitioners. (Rolls his eyes.)
08:11:29 <elliott> THEO Ok, fine (tired of the practitioners’ conversation).
08:12:17 <pikhq> It seems that how it handles ungetc is by being clever enough that ungetc itself is easy. :P
08:12:28 <monqy> i like the part where theo writes some formal definitions to the whiteboard: seman-
08:12:31 <monqy> tic brackets, Greek letters, languages as sets, etc.
08:12:48 <monqy> i am imagining this takes him a while and the others just sit and watch him intently
08:12:51 <zzo38> Perhaps turn off ligatures, they are not very good for fixed-pitch text
08:13:05 <elliott> monqy: he literally just writes those words
08:13:32 <monqy> can easily be coded in haskell
08:13:41 <elliott> HAZEL Well, we have a cute program, elegant, efficient, concise,
08:13:41 <elliott> solving a relevant problem. What else do you want?
08:13:49 <elliott> THEO A friend who I'm not a sarcastic piece of shit to.
08:13:57 <elliott> HAZEL You know you can never have that, Theo.
08:14:29 <monqy> T HEO But how do we make our story a fun essay?
08:14:29 <monqy> The three turn to the audience, bright smiles on their
08:15:12 <elliott> type ReadTable = Map Char AnteValue -- function from handle -> object
08:15:23 <elliott> I just need to let environments have arbitrary objects as keys
08:15:55 <monqy> are environments good keys
08:18:25 <zzo38> You need the appropriate key! The red door is locked!
08:18:44 <elliott> monqy: fdk glkkobgfnldmgdf
08:18:59 <elliott> monqy: should quote be used as (quote . x) => x or (quote x) => x
08:19:07 <elliott> picolisp does former, most things do latter
08:19:14 <elliott> zeptoability in question of both
08:20:18 <elliott> "British website owners could face extradition to the US on piracy charges even if their operation has no connection to America and does something which is most probably legal in the UK, the official leading US web anti-piracy efforts has told the Guardian."
08:20:19 <monqy> the . is a little bizarre there does it mean the same thing as it does in scheme
08:20:39 <elliott> <monqy> the . is a little bizarre there does it mean the same thing as it does in scheme
08:20:47 <elliott> pico does it because it means quote is faster, its just cdr rather than cadr :P
08:21:05 <elliott> (quote a b) has no useful meaning afaik
08:21:11 <elliott> it seems like (quote . a) is more...
08:21:22 <elliott> no other form acts like that
08:22:22 <monqy> keeping it like other forms sounds nice to me
08:22:35 <elliott> /home/elliott/Code/ante/ante.hs:150:34: Not in scope: `liftMtwo'
08:23:26 <elliott> ?undo do dfjg <- read e h; dd <- cons dfjg AnteNil; cons (AnteSymbol "quote") dd
08:23:26 <lambdabot> read e h >>= \ dfjg -> cons dfjg AnteNil >>= \ dd -> cons (AnteSymbol "quote") dd
08:23:31 <elliott> ?pl read e h >>= \ dfjg -> cons dfjg AnteNil >>= \ dd -> cons (AnteSymbol "quote") dd
08:23:31 <lambdabot> cons (AnteSymbol "quote") =<< flip cons AnteNil =<< read e h
08:23:41 <elliott> ?pl \e h -> cons (AnteSymbol "quote") =<< flip cons AnteNil =<< read e h
08:23:41 <lambdabot> (((cons (AnteSymbol "quote") =<<) . (flip cons AnteNil =<<)) .) . read
08:24:10 <elliott> oh damn I need to call read anteRead
08:24:15 <monqy> . sections are scary
08:24:39 <monqy> all the more zepto i guess
08:24:51 <zzo38> What do these "Ante" things mean anyways?
08:25:30 <oerjan> @pl \a b c d e f g h -> a (b (c d e) (f g)) h
08:25:31 <lambdabot> (. (((((.) .) .) .) . (.) . (.))) . (.) . (.) . (.) . (.) . (.)
08:31:18 <elliott> monqy: oh this is going to be hard are
08:31:59 <monqy> instance Eq (IORef a) -- Defined in GHC.IORef
08:32:54 <zzo38> Please join my TeXnicard project so that we can make something TeXnicard.
08:33:09 <monqy> maybe in caleskell
08:33:20 <monqy> how do you do the info thing
08:33:23 <zzo38> elliott: I don't mean you.
08:33:40 <monqy> when I did :i in ghci it only gave Eq
08:34:04 <zzo38> Someone else who doesn't mean "no".
08:34:17 <monqy> oh there's a Typeable1 instance too??
08:34:25 <elliott> monqy: yes its the height of luxury
08:34:55 <oerjan> presumably GC can move it about?
08:35:26 <oerjan> so Ord may not be safe
08:35:47 <monqy> -- explicit instance because Haddock can't figure out a derived one
08:35:48 <monqy> instance Eq (IORef a) where IORef x == IORef y = x == y
08:35:51 <monqy> what is this nonsense
08:36:06 <lambdabot> newtype IORef a = IORef (STRef RealWorld a)
08:36:08 <monqy> oh it depends on the STRef Eq instanced
08:36:11 <lambdabot> data STRef s a = STRef (MutVar# s a)
08:36:35 <elliott> MutVar# is primitive i think
08:36:44 <oerjan> hm data so MutVar# is probably unboxed
08:36:52 <monqy> -- Just pointer equality on mutable references:
08:36:52 <monqy> instance Eq (STRef s a) where STRef v1# == STRef v2# = sameMutVar# v1# v2#
08:37:19 <elliott> oerjan: well # implies unboxed...
08:37:36 <oerjan> i'm not sure of that...
08:37:39 <elliott> oerjan: remember, different kind
08:37:59 <oerjan> um the # in names has no automatic meaning :P
08:38:12 <zzo38> Anyone programming in C or CWEB or Plain TeX or understanding these kind of card game or anything else relevant to the project, can join, if you want to, please.
08:38:35 <elliott> oerjan: are you sure? I think it does for types
08:38:41 <elliott> oerjan: you can't define your own Foo# type
08:39:00 -!- yorick_ has joined.
08:39:06 <oerjan> elliott: um you need MagicHashes, of course
08:39:18 <oerjan> but afaik that only extends syntax
08:40:22 <oerjan> !haskell {-# LANGUAGE MagicHashes #-} data Foo# = Foo# Int deriving Show; main = print $ Foo# 0
08:40:31 <EgoBot> /tmp/input.6121.hs:1:13: unsupported extension: MagicHashes
08:40:31 <Deewiant> ptrEq x y = do nx <- makeStableName x ny; <- makeStableName y; return (nx == ny)
08:40:42 <oerjan> !haskell {-# LANGUAGE MagicHash #-} data Foo# = Foo# Int deriving Show; main = print $ Foo# 0
08:40:57 <oerjan> elliott: works perfectly
08:41:34 <oerjan> it's just for things they don't want people to muck about with needlessly
08:42:14 <elliott> oerjan: i think it's because it's non-standard, dude :P
08:42:50 <olsner> also, for translating shootout benchmarks from C to Haskell
08:43:41 -!- yorick has quit (*.net *.split).
08:47:48 -!- cheater_ has joined.
08:53:15 <elliott> oerjan: i would like to mark down on the record how much IORefs in ADTs sucks in haskell
08:53:34 <monqy> but records suck too.......
08:53:45 <elliott> got a function somewhere? or an IORef? wanna use your value as a Map key?
08:53:49 <elliott> ha ha ha oh boy, HAVE FUN WITH THAT
08:54:40 -!- cheater_ has quit (Ping timeout: 255 seconds).
08:54:48 <Deewiant> Writing an Ord instance that ignores them isn't exactly a huge pain
09:04:57 <elliott> Deewiant: um such an Ord instance won't work for Map will it?
09:05:03 <elliott> data Ref a = Ref !Int !(IORef a)
09:05:03 <elliott> instance Eq (Ref a) where Ref i _ == Ref j _ = i == j
09:05:03 <elliott> instance Ord (Ref a) where compare (Ref i _) (Ref j _) = compare i j
09:05:03 <elliott> instance Show (Ref a) where show = const "<Ref>"
09:05:09 <elliott> with a global unsafePerformIO'd ioref to keep track of the top index
09:05:43 <Deewiant> Also, globall unsafePerformIO'd ioref: and you don't like my code...
09:06:05 <elliott> Deewiant: It's completely encapsulated, and only exists because GHC is dumb and doesn't have its own ioref IDs :P
09:06:45 <elliott> I don't know what you mean by "your code", though, unless I've complained at your HIDEOUS SINS AGAINST PROGRAMMING before in which case probably feel bad
09:07:36 -!- yorick_ has changed nick to yorick.
09:09:13 <oerjan> Deewiant: <elliott> Deewiant: please...stop existing...
09:09:49 <monqy> wasnt this the one that wasnt that one
09:09:52 <elliott> ok i need to go unconscious for some hours now bye
09:09:53 <monqy> something about stablenames
09:09:59 <elliott> monqy: unsafeperformio for showing ioref
09:10:07 <elliott> monqy: ok i will ill try and hallcuating
09:12:12 <oerjan> monqy: apparently StableNames don't have Ord either
09:14:26 -!- elliott has quit (Ping timeout: 246 seconds).
09:17:08 <fizzie> oerjan: "Stable, not sorted"; isn't that how James Bond likes his drinks?
09:22:10 -!- Lymee has quit (Ping timeout: 240 seconds).
09:23:31 -!- Lymee has joined.
09:36:19 -!- cheater_ has joined.
09:38:20 -!- Vorpal has joined.
09:38:26 <zzo38> Is the random number generator algorithm in TeXnicard OK? Is there anything wrong with it?
09:40:34 -!- cheater_ has quit (Ping timeout: 255 seconds).
09:40:39 -!- monqy has quit (Quit: hello).
09:44:01 -!- oerjan has quit (Quit: Good night).
09:51:06 -!- augur has quit (Read error: Connection reset by peer).
09:53:01 -!- augur has joined.
10:16:04 -!- zzo38 has quit (Quit: Unstable cards.).
11:35:40 -!- ineiros has quit (Ping timeout: 240 seconds).
12:05:16 -!- ais523 has quit (Remote host closed the connection).
12:10:06 -!- CakeProphet has joined.
12:10:07 -!- CakeProphet has quit (Changing host).
12:10:07 -!- CakeProphet has joined.
12:16:18 -!- boily has joined.
12:20:24 -!- boily has quit (Client Quit).
12:21:27 -!- boily has joined.
12:33:28 -!- BeholdMyGlory has joined.
12:58:02 -!- azaq23 has joined.
14:43:45 -!- adam____ has joined.
14:48:31 -!- CakeProphet has quit (*.net *.split).
14:56:09 -!- Sgeo has joined.
14:57:25 -!- cheater_ has joined.
15:01:53 -!- cheater_ has quit (Ping timeout: 255 seconds).
15:02:07 -!- copumpkin has joined.
15:02:07 -!- copumpkin has quit (Changing host).
15:02:07 -!- copumpkin has joined.
15:13:33 -!- Sgeo has quit (Read error: Connection reset by peer).
15:14:28 -!- Sgeo has joined.
15:19:48 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:40:49 -!- Sgeo_ has joined.
15:42:34 -!- Sgeo__ has joined.
15:43:44 -!- Sgeo has quit (Ping timeout: 255 seconds).
15:45:32 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
15:47:20 -!- Sgeo__ has quit (Ping timeout: 255 seconds).
15:49:07 -!- monqy has joined.
15:55:56 -!- Sgeo has joined.
15:56:11 -!- Sgeo has quit (Client Quit).
16:29:05 -!- Cocytus has joined.
16:29:56 <Cocytus> sorry guys this is my room. it's for Esoteric Philosophy...programming language is of course one avenue of Philosophy so you are welcome to stay and discuss amongst everyone.
16:31:18 <Cocytus> that being said........Ave.
16:31:24 -!- Cocytus has left.
16:31:36 <fizzie> Oh no, we're in his room. :/
16:57:54 -!- cheater_ has joined.
17:00:35 -!- ineiros has joined.
17:23:15 <cheater_> you are standing at the end of a road before a small brick building.
17:23:21 -!- zzo38 has joined.
17:28:35 -!- cheater_ has quit (Ping timeout: 255 seconds).
17:29:59 -!- cheater_ has joined.
17:33:23 -!- copumpkin has joined.
17:33:23 -!- copumpkin has quit (Changing host).
17:33:23 -!- copumpkin has joined.
17:51:09 -!- esowiki has joined.
17:52:05 -!- esowiki has joined.
17:52:50 -!- esowiki has joined.
17:52:50 -!- glogbot has joined.
17:52:50 <?unknown?> [freenode-info] please register your nickname...don't forget to auto-identify! http://freenode.net/faq.shtml#nicksetup
18:01:26 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:03:28 -!- cheater_ has joined.
18:22:35 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:33:20 -!- pikhq_ has joined.
18:33:49 -!- cheater_ has joined.
18:34:10 -!- pikhq has quit (Ping timeout: 240 seconds).
18:41:18 -!- pikhq has joined.
18:43:44 -!- cheater_ has quit (Ping timeout: 240 seconds).
18:43:52 -!- pikhq_ has quit (Ping timeout: 240 seconds).
18:44:59 -!- cheater_ has joined.
18:46:27 -!- KingOfKarlsruhe has joined.
18:50:40 -!- cheater_ has quit (Ping timeout: 250 seconds).
18:51:41 -!- cheater_ has joined.
18:55:03 -!- quintopia has quit (Ping timeout: 252 seconds).
18:56:20 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:58:33 -!- quintopia has joined.
18:58:34 -!- quintopia has quit (Changing host).
18:58:34 -!- quintopia has joined.
19:16:44 -!- BeedaWeeda has joined.
19:19:55 <Phantom_Hoover> I have the choice between YouTube binging on The Chaser, or on Dead Ringers.
19:20:59 -!- MigoMipo has joined.
19:23:59 -!- oerjan has joined.
19:24:31 <Phantom_Hoover> I like the way The Chaser were always able to find John Howard for their stunts.
19:26:05 <oerjan> while you welsh are cwwl
19:28:03 -!- pikhq_ has joined.
19:28:41 -!- hiato_ has quit (Ping timeout: 258 seconds).
19:30:02 -!- pikhq has quit (Ping timeout: 264 seconds).
19:34:38 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
19:35:50 -!- hiato has joined.
19:49:51 <oerjan> "Today I want to talk about the status of the question and baseball."
19:50:34 <oerjan> *"Today I want to talk about the status of the P = NP question and baseball."
19:50:58 <Zwaarddijk> is there any progress on it currently?
19:51:24 <Zwaarddijk> with double or triple spaces between the article and noun
19:53:11 <oerjan> Zwaarddijk: nothing immediately promising that i know of
19:55:31 <oerjan> although maybe the rest of http://rjlipton.wordpress.com/2011/07/04/getting-on-base-with-pnp/ may count as a little survey of the case
20:09:55 -!- elliott has joined.
20:11:15 <elliott> 16:29:05: -!- Cocytus has joined #esoteric.
20:11:15 <elliott> 16:29:56: <Cocytus> sorry guys this is my room. it's for Esoteric Philosophy...programming language is of course one avenue of Philosophy so you are welcome to stay and discuss amongst everyone.
20:11:15 <elliott> 16:31:18: <Cocytus> that being said........Ave.
20:11:15 <elliott> 16:31:24: -!- Cocytus has parted #esoteric.
20:11:54 <oerjan> should have told him about Malbolge
20:12:04 <olsner> elliott: that was you under a differen nick, wasn't it?
20:12:54 <oerjan> i do not know elliott to use comcast, but who knows
20:21:02 -!- adam____ has quit (Ping timeout: 264 seconds).
20:23:00 -!- CakeProphet has joined.
20:24:14 <elliott> http://en.wikipedia.org/wiki/List_of_atheists <-- list of famous bisexuals
20:25:35 <olsner> probably more like FixF [] Atheist
20:26:00 <lambdabot> Not in scope: data constructor `FixF'
20:26:18 <elliott> data FixF f a = Foo a | Bar (f (FixF f a)), presumably
20:26:52 <olsner> actually, the FixF I was thinking of would be a bit hard to use since you'd never get to the Atheists
20:26:54 <elliott> unless olsner means a two-argument Mu, in which case it's a very useless type :D
20:29:58 <monqy> antezepto specifically?
20:30:19 <elliott> monqy: i am sorry to report
20:30:25 <elliott> monqy: that .............................................................................................
20:30:31 <elliott> monqy: my impl is broken :(
20:30:42 <elliott> its not enough to just compare references by pointer equality, because
20:30:46 <elliott> | AntePair !(Ref AnteValue) !(Ref AnteValue)
20:30:54 <elliott> if you have a map with key (a b)
20:31:03 <olsner> I think something like FixF (Either Atheist `O` []) Atheist is more what I meant, i.e. what elliott said
20:31:05 <elliott> only the same object will look it up, pretty much
20:31:34 <elliott> monqy: so what I need is a map where compare and (==) are done in IO?
20:31:43 <monqy> aaaaaaaaaaaaaaaaaaa
20:32:24 <monqy> is there any way around it
20:33:03 <elliott> monqy: I can't think of one that doesn't involve unsafePerformIO
20:33:08 <olsner> I meant FixF from http://hackage.haskell.org/packages/archive/category-extras/0.53.5/doc/html/Control-Functor-Fix.html and I didn't even remember it right... fail :(
20:33:10 <elliott> <monqy> aaaaaaaaaaaaaaaaaaa
20:33:18 <elliott> olsner: category-extras is deprecated >:|
20:33:50 <olsner> aha, so that's why it's not indexed by hoogle then
20:33:59 <olsner> why did it get deprecated?
20:34:03 <elliott> into a bunch of mostly-haskellninetyeight packages
20:34:03 <monqy> is there any way to cleanly encapsulate the unsafePerformIO
20:34:17 <monqy> alternatively, construct everything else in such a way that doing this wackness isn't necessary
20:34:19 <elliott> olsner: I think because it's really huge and unfocused (= big monolithic dependency), plus it relies on like five thousand extensions
20:34:28 <elliott> olsner: so he's trying to separate everything into really portable haskell ninetyeight code
20:34:33 <elliott> and separate out the unportable stuff
20:34:40 <elliott> while putting it all into different packages
20:37:34 <elliott> dunno where the replacement for that module is though :D
20:38:19 <Deewiant> ?ty let f _ [] = return Nothing; f p (x:xs) = p x >>= \b -> if b then return (Just x) else f p xs in f -- there's your map in IO
20:38:20 <lambdabot> forall a (m :: * -> *). (Monad m) => (a -> m Bool) -> [a] -> m (Maybe a)
20:38:57 -!- CakeProphet has quit (Read error: Operation timed out).
20:39:17 <elliott> monqy: hmm, if you use (0 9) as an environment key, then mutate the car so it's (9 9), should the environment key mutate or should environment keys get copied
20:39:32 <elliott> but what if you get (0 9) out of the keys list of the environment, and mutate it, WHAT THEN
20:39:44 <elliott> (answer: it should probably copy keys before giving them back, too)
20:41:43 <olsner> functor fixpoints are easy to define when you need one, so if category-extras is deprecated you can just opt not to use it
20:41:52 -!- CakeProphet has joined.
20:50:11 <elliott> monqy: Hmm, I could make map keys be immutable
20:50:16 <elliott> monqy: By making a version of AnteValue with no IORefs
20:50:21 <elliott> Or parameterising it on the type of references
20:50:27 <elliott> monqy: But, ugh, that seems like a Pain
20:50:30 <monqy> would this fix your broken
20:55:49 -!- KingOfKarlsruhe has quit (Quit: ChatZilla 0.9.87 [Firefox 5.0/20110615151330]).
21:14:37 -!- cheater_ has joined.
21:33:17 -!- hagb[4]rd has joined.
21:33:21 -!- MigoMipo has quit (Read error: Connection reset by peer).
21:35:20 -!- azaq23 has quit (Quit: Leaving.).
21:39:22 -!- hagb[4]rd has changed nick to hagb4rd.
21:44:05 -!- CakeProphet has quit (Ping timeout: 252 seconds).
21:45:19 -!- CakeProphet has joined.
21:45:19 -!- CakeProphet has quit (Changing host).
21:45:20 -!- CakeProphet has joined.
21:54:51 -!- |||Ksarks||| has joined.
21:56:09 -!- |||Ksarks||| has left.
22:05:49 -!- azaq23 has joined.
22:07:20 -!- CakeProphet has quit (Ping timeout: 276 seconds).
22:07:54 -!- CakeProphet has joined.
22:07:54 -!- CakeProphet has quit (Changing host).
22:07:55 -!- CakeProphet has joined.
22:11:21 <HackEgo> 479) Nobody actually said this; this is just a demonstration.
22:11:27 <tswett_> Now, how do I get rid of it?
22:11:54 <tswett_> It has now been delled, I guess.
22:14:46 -!- myndzi has quit (Ping timeout: 258 seconds).
22:17:56 -!- cheater_ has quit (Ping timeout: 255 seconds).
22:32:53 <elliott> monqy: i just realised these changes mean you can bind an integer as a variable
22:33:08 <elliott> not that 9 will evaluate to anything, only symbols look themselves up in the environment
22:33:13 <oerjan> that could be a great FORTE
22:33:28 <elliott> oerjan: Funny, I just opened a buffer to implement Forte a few minutes ago.
22:35:44 <oerjan> hm first vau, now integers as variables. is your new language gradually absorbing everything else weird?
22:36:25 <elliott> oerjan: um you realise zepto always had vau? it was just equivalent to quote (and thus not given a name), because it was dynamically scoped
22:36:28 <elliott> i.e., no environment to save
22:36:37 <elliott> so (argname . body) was an acceptable lambda representation
22:36:53 <elliott> ante-zepto is lexically scoped, so it needs an actual operation to store the current environment in too
22:37:08 <elliott> oh, and it has another parameter to name the environment the fexpr is called in
22:37:19 <elliott> which didn't exist, again, in the dynamic version
22:37:28 * oerjan is divided on whether "in too" is a misspelling or not
22:37:45 <elliott> hmm, i dunno what that happened there
22:39:09 <oerjan> hm could you make a TC language which had hygienic macros and nothing else
22:40:04 <oerjan> i mean something like statically scoped fexprs but with all environments implicit. also this is very vague.
22:42:09 <oerjan> ("this is very vague" is here a synonym for "i'm not sure what i mean there")
22:43:07 <oerjan> someone said recently that hygienic macros are easy to implement if you do it in the base implementation
22:43:13 <oerjan> or something like that
22:45:31 -!- Sgeo has joined.
22:46:50 <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot?
22:47:53 -!- Sgeo has quit (Client Quit).
22:50:14 -!- foocraft has joined.
22:50:53 -!- CakeProphet has quit (Ping timeout: 276 seconds).
22:51:40 <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
22:52:02 -!- CakeProphet has joined.
22:53:12 <oerjan> eek, what have i done.
22:58:11 <elliott> `addquote <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot? [...] <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
22:58:12 <HackEgo> 479) <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot? [...] <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
23:16:26 <elliott> "Any scripting language (Python, Ruby, Perl) will IMO teach bad practices. Start off with something with more structure and less help. C++ or Java.
23:16:26 <elliott> Higher level scripting languages come with conveniences that are not found at other levels of programming. Callback functions, .each loops, dynamic typing, built-in operators, libraries. These are all detrimental to your overall mindset. Limit the comforts available until he can create those comforts himself.
23:16:26 <elliott> Start off dumb. Working in something like C++ or Java that forces you to choose a type for your variable and offers excellent language structure enhances your ability to think like a programmer. Then moving on to "smarter" languages will be easier."
23:16:34 <elliott> THIS WAS ACTUALLY NOT VOTED DOWN INTO OBLIVION
23:16:54 <elliott> "START WITH A LOW LEVEL LANGUAGE, NOT HAVING TO THINK ABOUT MINUTIAE DAMAGES THINKING ....... SO CLEARLY USE JAVA, THE MOST LOW-LEVEL OF ALL LANGUAGES"
23:16:58 <elliott> PFFAFAPAHAHAHAHAAHAHAHAHAHAHAHAAHAHAHA
23:23:11 <monqy> i wonder what that guy would say about starting with a functional language
23:23:38 <elliott> THATS SO MANY STEPS ABOVE JAVA ITS BAD
23:24:04 <newsham> java is a functional language
23:26:42 <elliott> http://programmers.stackexchange.com/questions/9621/teach-linux-programming-to-home-schooled-15-year-old, found while absent-mindedly traversing the graph of programmers.stackexchange, a terrible place.
23:28:19 <Phantom_Hoover> "If this is a learning experience, something like R is probably the most useful thing. It will teach him problem-solving skills as well as the ability to load and analyze data files, which is also very useful."
23:28:34 <Phantom_Hoover> I have picked up the general impression from here that R is somewhat insane.
23:28:38 <newsham> http://www.thenewsh.com/~chat/j/XXPrelude.java
23:28:54 <newsham> oops, http://www.thenewsh.com/~chat/j/XPrelude.java this one
23:30:00 <elliott> newsham: meh, it's not impressive until you get monads
23:30:05 <elliott> I think http://functionaljava.org/ has them :P
23:30:21 <newsham> i havent tried to play with typeclasses at all
23:30:31 <elliott> monads have nothing to do with typeclasses.
23:30:40 <elliott> you would want to implement it as
23:30:58 <elliott> data Monad m = Monad { return :: forall a. a -> m a; bind :: forall a b. m a -> (b -> m b) -> m b }
23:31:16 <monqy> who was it that did pattern matching in java
23:31:18 <newsham> phantom: X's for "lets try another approach, maybe i should rename this to preserve the original" :)
23:31:27 <monqy> using exceptions or something like that
23:31:53 <newsham> also you dont need teh monads to be funkshunal
23:32:39 <Phantom_Hoover> newsham, yeah, but without them you lack monad tutorials, a vital part of any functional programming community.
23:33:28 <elliott> // A lot of type annotation
23:33:28 <elliott> final HAppend<HNil, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:28 <elliott> HCons<Double, HCons<String, HCons<Integer[], HNil>>>> zero = append();
23:33:28 <elliott> final HAppend<HCons<Boolean, HNil>, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:29 <elliott> HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>> one = append(zero);
23:33:30 <elliott> final HAppend<HCons<Integer, HCons<Boolean, HNil>>, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:31 <newsham> the view of half of the community is that not supporting monad tutorials is a feature
23:33:33 <elliott> HCons<Integer, HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>>> two = append(one);
23:33:36 <elliott> final HAppend<HCons<String, HCons<Integer, HCons<Boolean, HNil>>>,
23:33:38 <elliott> HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:42 <elliott> HCons<String, HCons<Integer, HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>>>>
23:33:58 <Phantom_Hoover> newsham, yeah, but that half is just bitter that they can't write a monad tutorial.
23:34:18 <newsham> whoa.. there are people who havent written monad tutorials?
23:34:29 <elliott> "@rei: Well, I have advanced social skills, [...]" --programmers.stackexchange
23:34:33 <oerjan> i have never written a monad tutorial.
23:34:41 <newsham> oerjan: perhaps you have and you didnt realize it
23:34:57 <elliott> oerjan: I believe you've tried to explain them in here before :D
23:34:59 <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:05 <newsham> did you write any tutorials that are isomorphic to monad tutorials?
23:35:08 <elliott> `addquote <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:09 <HackEgo> 480) <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:12 -!- Sgeo has joined.
23:36:13 <oerjan> life, a reverse state monad
23:37:10 <newsham> happy 4th of july, state monad!
23:37:20 <Sgeo> Wired does not, in fact, seem to be faster than wireless
23:38:10 <newsham> Mon Jul 4 13:34:50 HST 2011
23:38:27 <monqy> the 4th doesnt matter there
23:38:44 <newsham> typical european response... assume all islanders are uncivilized
23:38:59 <Phantom_Hoover> monqy, sorry who did they declare themselves independent from.
23:39:09 <elliott> newsham: You're all uncivilised, apart from the natives.
23:39:19 <oerjan> ...americans are islanders and brits not, now?
23:39:37 <newsham> we didnt much care for all the taxation without representation, phantom.
23:39:51 <newsham> although these days the radical right seems to be fighting for less representation.
23:40:04 <monqy> fourth makes me mad
23:40:15 <monqy> loud noises and idiocy makes my head ache
23:40:21 <newsham> but drunk does not make me mad
23:40:45 <elliott> monqy: loud noises are unzepto
23:40:57 <monqy> what about idiocy i hope
23:41:43 <oerjan> elliott: have you considered the possibility that zepto may not be implementable in this imperfect world
23:41:55 <Phantom_Hoover> newsham, yeah but the fundamental point is that you were a British colony so you logically declared independence in British time true fact.
23:42:15 <newsham> i was never a british colony
23:42:53 <newsham> most of me was being kicked around eastern europe at the time this all went down
23:42:58 <elliott> 05:34:29: <elliott_> oerjan: ah. you would think. but a failed bootstrapping is not very zepto.
23:42:58 <elliott> 05:34:43: <elliott_> and if you lose the binary, as zepto people are wont to do, then that would make it a very un-zepto situation.
23:42:58 <elliott> 05:34:55: <elliott_> also, compilers are un-zepto, so that's just too recursive for the universe to handle.
23:42:58 <elliott> 05:35:02: <elliott_> although that, in itself, is very zepto, we are unfortunately constrained.
23:42:58 <elliott> 05:35:05: <elliott_> we cannot achieve true zepto.
23:43:00 <elliott> 05:35:08: <elliott_> we can only achieve universal zepto.
23:43:02 <newsham> or at least most of the people who led to me
23:43:06 <oerjan> Phantom_Hoover: but timezones weren't invented back then!
23:43:34 <newsham> didnt ben franklin help come up with daylight savings time? did that happen before ther ewere timezones?
23:43:45 <monqy> daylight savings time is the worst
23:43:56 <Phantom_Hoover> newsham, so you are therefore inextricably tied to eastern European time Q.E.D.
23:44:11 <newsham> phantom: some would say I'm the white devil.
23:46:02 <oerjan> <newsham> most of me was being kicked around eastern europe at the time this all went down <-- wait does this mean newsham isn't your real name
23:46:56 <newsham> one out of four of my grandparents were called newsham
23:47:43 <Phantom_Hoover> oerjan, what, do you think they didn't have pigs that announced current events in eastern Europe?
23:48:04 <oerjan> Phantom_Hoover: well it _could_ be translated of course.
23:48:06 <newsham> phantom: check out newsham.com
23:48:20 <newsham> but you might chuckle anyway
23:48:49 <newsham> apparently lots of pig farming in the newsham line
23:49:30 <elliott> newsham: that isn't real is it?
23:49:47 <elliott> Your choice for performance and longevity. A proven maternal leader.
23:50:19 <newsham> some of the newsham/newsome coat of arms have pigs on em, too
23:52:01 <oerjan> your SuperMom™ so fat, she can be used in the penrose process
23:52:06 <newsham> not to worry, recent family is all poor working class
23:52:20 -!- Vorpal has quit (Ping timeout: 260 seconds).
23:52:46 <Phantom_Hoover> newsham, yeah, but there are like no interesting people with my last name.
23:53:26 <newsham> you have a low self opinion?
23:54:09 <newsham> i assume you have your last name
23:54:20 <oerjan> <newsham> didnt ben franklin help come up with daylight savings time? did that happen before ther ewere timezones? <-- last i heard he was joking.
23:55:20 <elliott> Phantom_Hoover: your name is cool tho
23:57:02 <oerjan> our family was so poor their coat had no arms
23:57:29 <newsham> google, the foundation of all credibility!
23:57:37 <newsham> no google, never happened.