←2011-09-15 2011-09-16 2011-09-17→ ↑2011 ↑all
00:00:46 <monqy> oh no
00:01:12 -!- Jafet has joined.
00:05:32 <CakeProphet> itidus21: meaning that anything in the program that goes "outside the bounds" of the system has either been designed as part of the system, or is most likely a bug/segfault.
00:05:46 <Lymee> http://i55.tinypic.com/15gwgwh.png < Pretty? :3
00:10:56 -!- Gregor has changed nick to Guest53387.
00:11:32 -!- Guest53387 has changed nick to Gregor.
00:11:40 <Gregor> Argh
00:12:29 <itidus21> CakeProphet: yeah..
00:13:11 <itidus21> a properly implemented chessboard and chess rules will never bring about a situation where the pieces can leave the board
00:13:36 <itidus21> leaving board has to be by design or by hacking/bugs
00:15:30 <itidus21> theres this problem that a game doesn't necessarily become better by being larger or more complicated
00:18:18 <monqy> how is that a problem
00:19:00 <itidus21> like it can be a memory test[eg the game memory], a reflex test[arcade/action games], a calculation test[puzzle/strategy games], a strength test[punching bag style games/some sports], a stamina test[some sports]
00:19:40 <itidus21> also.. it can be a test of how much time and money you have
00:20:41 <itidus21> the idlerpg game is like a test of how long you can maintain an irc connection
00:21:55 <itidus21> some games where you can buy items or priviliges with real world money show that off... and being able to afford better internet connections or living in country with good internet can improve that
00:22:01 -!- augur has quit (Remote host closed the connection).
00:22:05 <Sgeo__> How about the game where you lose if someone else starts playing within a certain time?
00:23:00 <itidus21> also games can be a test of the ability to cheat or hacking it
00:24:31 <itidus21> monqy: because i want to think up a cool game.. and it would be easy if all i had to do was say "bigger! more complicated!"
00:25:15 <itidus21> the trick is that a game does not infact prove superiority of one over another.. it is an illusion of the ego
00:29:49 <itidus21> so, another way i try to look at it is the value of art
00:30:01 -!- ive has quit (Ping timeout: 276 seconds).
00:31:03 <itidus21> poetry, novels, drawings, paintings, musical compositions, sculptures, garden arrangements, house decoration
00:31:15 <itidus21> ^film
00:31:17 -!- copumpkin has joined.
00:31:54 <itidus21> theater plays, operas, orchestras, concerts, puppet shows, circuses
00:32:45 <itidus21> singing, dancing
00:33:58 <itidus21> origami, martial arts, fashion
00:34:34 <itidus21> cooking
00:35:06 <oerjan> bonsai kittens
00:35:52 * oerjan waits for itidus21 to run away screaming
00:36:46 <itidus21> now whether science, mathematics, physics, electronics, engineering, philosophy, religion, programming etc, fits in with that first list i am not sure
00:37:08 <Jafet> Sex.
00:42:25 <itidus21> now these things difficult to classify religion, business, politics, law, military, sales, marketing, tourism, psychology(could be science)
00:42:37 -!- CakeProphet has quit (Ping timeout: 252 seconds).
00:43:08 <itidus21> the last ones seem to be a category of things which are particularly social in nature
00:44:01 -!- oerjan has quit (Quit: Good night).
00:44:17 <itidus21> so, i am left wondering where gaming fits in to all this
00:45:11 <itidus21> is it a drug.. is it a shallow consumable..
00:45:21 <itidus21> is it an artform
00:45:30 <itidus21> is it a science
00:47:02 <itidus21> perhaps a game can be enjoyed or not enjoyed in just the same way as everything else
00:47:57 -!- qnix has joined.
00:48:23 <itidus21> upon a stable basis of friendly people wanting to interact a game can perform it's magic
01:03:46 <itidus21> so drawing my attention now to how games are played. chess tables in a park. gambling in wild west saloons. casinos. basketball courts. football fields. olympic stadiums. racing tracks. slot car racing venues. golf courses. arcade game places.
01:04:07 <itidus21> billiads/pool halls.
01:04:25 <itidus21> ^bulliards
01:07:02 <itidus21> on a phone. bedroom PC. a lan cafe. lan parties. family tv with console attached. tabletop games like board games, military sims, role playing games
01:07:59 <itidus21> marble games often played outdoors
01:09:31 <itidus21> i spy, charades, travel versions of some board games
01:09:51 <itidus21> newspaper puzzles, magazine puzzles,
01:10:13 <itidus21> live action role playing games(LARP)
01:11:13 <itidus21> hop scotch. tennis ball bouncing games, such as bouncing in squares of pavement or bouncing off a wall
01:11:48 <itidus21> easter egg hunts
01:13:28 <itidus21> some games seems to be played for entertainment, some played for profit..
01:14:25 <itidus21> some for .. i don't know.. i can't really understand mathematicians or why they play mathematical games
01:15:50 <itidus21> perhaps those are also entertaining, but there is certainly some educational value to some games too
01:16:37 <itidus21> however, education of course is a means and not an end, and yet we hope that we never stop learning
01:17:59 * itidus21 walks off in the twilight among the chirps of crickets, satisfied.
01:21:00 -!- HolyBlood has joined.
01:28:02 -!- HolyBlood has quit.
01:30:02 -!- CakeProphet has joined.
01:30:24 <CakeProphet> sex with bonsai kittens?
01:32:36 <monqy> ew
01:33:43 <CakeProphet> !kill monqy
01:36:04 -!- kmc has quit (Ping timeout: 260 seconds).
01:36:12 <monqy> hi
01:36:25 <Jafet> And I thought the psycho-babble thing was a joke
01:36:32 <CakeProphet> nope.
01:36:39 <CakeProphet> it is most definitely not a joke.
01:36:43 <CakeProphet> it is our tpic.
01:37:00 <Jafet> Shit just god Freudian
01:37:10 <Jafet> gott, even
01:37:17 <CakeProphet> Freudian slip.
01:37:33 <CakeProphet> hmmmm
01:38:01 <CakeProphet> so I have: caramel frappucino, banana foster, pumpkin spice, and fuzzy peach
01:38:07 <CakeProphet> which flavors should I mix into my hookah bowl?
01:43:55 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< pick (filterM (const [True, False]) ["cf, "bf", "ps", "fp"]) where pick ls = randomRIO (0, length ls) >>= (ls!!)
01:44:54 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< pick (filterM (const [True, False]) ["cf", "bf", "ps", "fp"]) where pick ls = randomRIO (0, length ls) >>= (ls!!)
01:46:02 <CakeProphet> oh...
01:46:30 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< pick (filterM (const [True, False]) ["cf", "bf", "ps", "fp"]) where pick ls = randomRIO (0, length ls) >>= (return.(ls!!))
01:46:31 <monqy> I see a few problems with that
01:46:35 <EgoBot> ​["bf","ps","fp"]
01:46:41 <CakeProphet> I NOW SEE NONE
01:46:53 <CakeProphet> that is actually a good combination..
01:47:22 <CakeProphet> I could just use fmap instead of >>= in pick
01:47:51 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< pick (filterM (const [True, False]) ["cf", "bf", "ps", "fp"]) where pick ls = (ls!!) <$> randomRIO (0, length ls)
01:48:08 <monqy> hheheheh
01:48:15 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< pick (filterM (const [True, False]) ["cf", "bf", "ps", "fp"]) where pick ls = (ls!!) `fmap` randomRIO (0, length ls)
01:48:19 <CakeProphet> monqy: shush
01:48:20 <EgoBot> ​["ps"]
01:48:22 <monqy> hheheheh
01:48:26 <CakeProphet> what? :P
01:48:29 -!- kmc has joined.
01:48:34 <monqy> what a boring mix
01:48:38 <monqy> at least you didn't get the empty list
01:48:41 <monqy> that would have been dreadful
01:48:42 <CakeProphet> well, one flavor alone is delicious.
01:49:07 <CakeProphet> why is <$> in Control.Applicative anyways.
01:49:09 <CakeProphet> it should be with fmap.
01:52:05 <CakeProphet> I wonder if there's a better way to do pick without using both length and !!
01:52:21 <CakeProphet> seems like you need the length to calculate the probability either way.
01:52:34 <CakeProphet> if you wanted it to be evenly distributed.
01:53:58 <CakeProphet> @pl pick ls = (ls!!) `fmap` randomRIO (0, length ls)
01:53:59 <monqy> you could also do it differently
01:53:59 <lambdabot> pick = liftM2 fmap (!!) (randomRIO . (,) 0 . length)
01:54:17 <CakeProphet> monqy: right that's basically the question I was asking. "I wonder if I could do it differently"
01:54:21 <monqy> hehehe
01:54:28 <monqy> I'm going to do it differently now
01:55:33 <CakeProphet> ah I know how you could do it differently.
01:55:41 <CakeProphet> .5 probability for each element.
01:55:47 <monqy> yes that's what i was going to do
01:55:48 <CakeProphet> basically skip the power set.
01:56:12 <CakeProphet> perhaps the power set is never the best way to do anything. :P
01:56:29 <monqy> getting the power set is a good way to get the power set
01:56:37 <CakeProphet> true enough.
01:56:56 <CakeProphet> it seems like most of the algorithms involving a power set can be reduced to something more efficient that is essentially equivalent.
01:58:14 -!- Jafet has quit (Quit: Leaving.).
01:58:53 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< filterM (randomRIO (False,True)) ["cf", "bf", "ps", "fp"]
01:59:01 <CakeProphet> bah
01:59:52 <CakeProphet> :t const <$> (undefined :: IO Bool)
01:59:53 <lambdabot> forall b. IO (b -> Bool)
02:00:00 <CakeProphet> :t const (undefined :: IO Bool)
02:00:00 <lambdabot> forall b. b -> IO Bool
02:00:10 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< filterM (const $ randomRIO (False,True)) ["cf", "bf", "ps", "fp"]
02:00:15 <EgoBot> ​["cf","bf"]
02:01:03 <CakeProphet> I think I'll try that one actually
02:01:06 <CakeProphet> sounds like a good combo.
02:02:30 <monqy> > unsafeCoerce (const Nothing :: a -> Maybe a) :: Int
02:02:31 <lambdabot> Not in scope: `unsafeCoerce'
02:02:38 <monqy> > Unsafe.Coerce.unsafeCoerce (const Nothing :: a -> Maybe a) :: Int
02:02:39 <lambdabot> Not in scope: `Unsafe.Coerce.unsafeCoerce'
02:02:39 <CakeProphet> also, today I learned this:
02:02:41 <monqy> oops
02:02:44 <CakeProphet> :t ap const const
02:02:45 <lambdabot> forall b. b -> b
02:03:05 <monqy> SKK
02:03:09 <CakeProphet> yes, is I
02:03:13 <monqy> yes
02:03:19 <monqy> isn't it common knowledge?
02:03:37 <CakeProphet> ....uh, you have a strange definition of "common knowledge"
02:04:29 <monqy> common knowledge amongst those who know anything about the ski combinator calculus
02:04:38 <CakeProphet> oh, well yes.
02:04:54 <CakeProphet> I'm not very good SKI though
02:04:56 <CakeProphet> or lambda calculus
02:04:58 <CakeProphet> or anything of that nature.
02:05:04 <CakeProphet> I just know what they are.
02:05:54 <CakeProphet> and then I learned:
02:05:57 <CakeProphet> let's see if I can remember it...
02:06:08 <CakeProphet> :t ap (const ap) const
02:06:09 <lambdabot> forall a b b1. (a -> b) -> (b1 -> a) -> b1 -> b
02:07:37 <CakeProphet> though I should have already known that one.
02:08:36 <CakeProphet> because it's B in BCKW
02:10:05 <CakeProphet> :t ap (const (ap id id )) (ap (ap (const ap) const) (const (ap id id)))
02:10:06 <lambdabot> Occurs check: cannot construct the infinite type: a = a -> b
02:10:06 <lambdabot> Probable cause: `id' is applied to too few arguments
02:10:06 <lambdabot> In the second argument of `ap', namely `id'
02:10:31 <monqy> (ap id id) is a bad idea
02:10:45 <CakeProphet> well, that would be Y... but Haskell doesn't allow that to type.
02:10:49 <monqy> i mean
02:12:10 <monqy> i guess i meant what i said oops
02:12:11 -!- augur has joined.
02:13:02 <CakeProphet> :t ap (id id)
02:13:03 <lambdabot> forall a b. ((a -> b) -> a) -> (a -> b) -> b
02:13:09 <CakeProphet> :t ap id id
02:13:09 <lambdabot> Occurs check: cannot construct the infinite type: a = a -> b
02:13:10 <lambdabot> Probable cause: `id' is applied to too few arguments
02:13:10 <lambdabot> In the second argument of `ap', namely `id'
02:13:14 -!- DH____ has quit (Read error: Connection reset by peer).
02:13:17 <CakeProphet> :t ap id
02:13:18 <lambdabot> forall a b. ((a -> b) -> a) -> (a -> b) -> b
02:13:28 -!- Jafet has joined.
02:13:34 -!- DH____ has joined.
02:13:50 <CakeProphet> @hoogle (a -> b) -> a
02:13:50 <lambdabot> Data.Function fix :: (a -> a) -> a
02:13:50 <lambdabot> Control.Monad.Fix fix :: (a -> a) -> a
02:13:50 <lambdabot> Data.Generics.Schemes everywhere :: (a -> a) -> a -> a
02:13:59 <CakeProphet> bah
02:15:15 <CakeProphet> !haskell :t id
02:15:17 <EgoBot> id :: a -> a
02:15:38 <CakeProphet> hmmm, but I can't import stuff.
02:16:21 <CakeProphet> oh well I'll find out what happens.
02:17:12 -!- DH____ has quit (Read error: Connection reset by peer).
02:18:21 <CakeProphet> !haskell import Unsafe.Coerce; import Control.Monad; main = print $ fix (1:) where fix = ap (const (ap id (unsafeCoerce id :: (a -> b) -> a))) (ap (ap (const ap) const) (const (ap id (unsafeCoerce id :: (a -> b) -> a))))
02:18:48 <CakeProphet> :P
02:20:58 <CakeProphet> not sure where the error is. it just says "compilation errors
02:21:00 <CakeProphet> "
02:21:43 <monqy> nice
02:22:25 <CakeProphet> obviously if I just tell the type system everything is okay then it'll work perfectly.
02:24:09 <CakeProphet> hmmm maybe...
02:24:41 <CakeProphet> !haskell import Unsafe.Coerce; import Control.Monad; main = print $ fix (1:) where fix = ap (const (ap id unsafeCoerce)) (ap (ap (const ap) const) (const (ap id unsafeCoerce)))
02:25:03 <CakeProphet> ah
02:25:44 <CakeProphet> !haskell import Unsafe.Coerce; import Control.Monad; import Control.Monad.Instances; main = print $ fix (1:) where fix = ap (const (ap id unsafeCoerce)) (ap (ap (const ap) const) (const (ap id unsafeCoerce)))
02:26:06 <CakeProphet> .....uh, no compilation errors I think.
02:26:11 <CakeProphet> so it just crashes I guess.
02:31:29 * Sgeo__ decides no one here wants to hear about what happened today.
02:31:35 <Sgeo__> And even if someone did: It's private.
02:32:04 <Sgeo__> I guess the fact that something happened that I deem private isn't private, though
02:32:32 <itidus21> yeah, we can take the burden of knowing something happened without knowing what it was
02:40:59 <Sgeo__> ?` Sgeo
02:40:59 <lambdabot> Maybe you meant: . ? @ v
02:41:04 <Sgeo__> `? Sgeo
02:41:06 <HackEgo> Sgeo invented Metaplace sex.
02:42:01 <CakeProphet> wow skype is incredibly shitty
02:42:07 <monqy> yep
02:43:28 <Sgeo__> Is there anything better than skype?
02:44:31 <CakeProphet> any IM client, for text conversations
02:44:33 <CakeProphet> or IRC
02:44:45 <Sgeo__> What about for video chat?
02:45:42 <CakeProphet> no idea.
02:45:55 <CakeProphet> wow
02:46:01 <CakeProphet> skype is completely unusuable right now.
02:46:04 <CakeProphet> how terrible.
02:46:11 * Sgeo__ highly doubts that ooVoo counts as better
02:46:21 <Sgeo__> Although it was working earlier
02:51:04 <CakeProphet> fungot: help you are gone.
02:53:15 <monqy> ;_;
03:02:56 <itidus21> `log smeg
03:03:00 <HackEgo> 2010-07-28.txt:00:05:30: * cpressey wonders who the smeg Casey & Andy are and why they've been mentioned three times in here today
03:03:22 <itidus21> `log smeg
03:03:25 <HackEgo> 2011-09-16.txt:03:03:00: <HackEgo> 2010-07-28.txt:00:05:30: * cpressey wonders who the smeg Casey & Andy are and why they've been mentioned three times in here today
03:03:31 <itidus21> o.o
03:04:12 <itidus21> `log loller
03:04:15 <HackEgo> 2005-09-07.txt:14:04:35: <kipple_> Aardwolf: are you the designer of Brainloller?
03:04:48 <itidus21> `log fuck
03:04:52 <HackEgo> 2008-08-12.txt:09:27:27: <AnMaster> asiekierka, you could make almost anything, after all brainfuck is turing complete
03:05:10 <itidus21> `log fuck
03:05:13 <HackEgo> 2010-10-16.txt:19:35:33: <pikhq> Well, it does fuck with your credit score a lot.
03:05:18 <itidus21> `log fuck
03:05:21 <HackEgo> 2011-09-15.txt:04:27:47: <elliott> Lymee: Fuck off
03:05:37 <itidus21> `log unusable
03:05:40 <HackEgo> 2010-10-21.txt:15:28:25: <Gregor> FURTHER DISCOVERY: document.elementFromPoint is effectively unusable.
03:06:30 <itidus21> `log mario
03:06:33 <HackEgo> 2011-08-11.txt:02:43:06: <Vorpal> ais523, btw I think you should be able to run around floating eyes to kill them. (Note: only makes sense if you played Mario64 I think)
03:06:49 <itidus21> `log #jesus
03:06:52 <HackEgo> 2011-08-09.txt:23:36:02: <Patashu> screw #jesus, terraria 1.0.6 is finally out http://www.terrariaonline.com/threads/1-0-6-changelog.50278/
03:07:32 <itidus21> `log http
03:07:36 <HackEgo> 2006-02-26.txt:17:26:59: <Keymaker> http://koti.mbnet.fi/yiap/stuff/antdata.txt
03:08:08 <itidus21> `log norris
03:08:11 <HackEgo> 2008-04-05.txt:03:27:07: <Slereah> Chuck Norris. Ninjas. Objectivist propaganda.
03:12:45 -!- Sgeo__ has changed nick to Sgeo.
03:13:27 <monqy> itidus21: hi
03:15:10 <Gregor> `url bin/log
03:15:11 <HackEgo> http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/bin/log
03:17:32 <Gregor> `fetch http://sprunge.us/JMhe
03:17:33 <HackEgo> 2011-09-16 03:17:32 URL:http://sprunge.us/JMhe [223] -> "JMhe" [1]
03:17:42 <Gregor> `run mv JMhe bin/log && chmod 0755 bin/log
03:17:44 <HackEgo> No output.
03:17:47 <Gregor> `log
03:17:49 <HackEgo> 2010-03-02.txt:01:01:26: <Gre​gor> ...
03:19:19 <Gregor> `log this log search feature sucks
03:19:21 <HackEgo> 2011-09-16.txt:03:19:19: <Gregor> `log this log search feature sucks
03:28:05 <itidus21> `log just using log to maintain some modicum of relaxation
03:28:07 <HackEgo> 2011-09-16.txt:03:28:05: <itidus21> `log just using log to maintain some modicum of relaxation
03:35:18 <qnix> any one extremely good with md5 collision and brainfuck language pm me ? :)
03:36:24 <shachaf> No one is good with MD5 coll... Oops, sorry, just got out of my time machine.
03:45:28 <itidus21> my theory that mondrian's style was already existant in flag designs
03:45:41 <itidus21> but not formalized
03:50:12 <CakeProphet> my flags are the best.
03:50:40 <CakeProphet> `celebrate
03:50:42 <HackEgo> ​/home/hackbot/hackbot.hg/multibot_cmds/lib/limits: line 5: exec: celebrate: not found
03:50:44 <CakeProphet> !celebrate
03:50:47 <CakeProphet> halp
03:50:53 <CakeProphet> @celebrate
03:50:53 <lambdabot> Unknown command, try @list
03:50:56 <CakeProphet> ?celebrate
03:50:56 <lambdabot> Unknown command, try @list
03:50:57 <CakeProphet> haaalp
03:51:15 <CakeProphet> ^celebrate
03:51:19 <CakeProphet> NO FUNGOT
03:51:24 <CakeProphet> fizzie: no fungot
03:51:36 <CakeProphet> > cycle "no fungot" --fizzie
03:51:37 <lambdabot> "no fungotno fungotno fungotno fungotno fungotno fungotno fungotno fungotno...
03:52:51 <CakeProphet> !haskell import System.Random;import Control.Monad; main = print =<< filterM (const $ randomRIO (False,True)) ["cf", "bf", "ps", "fp"]
03:52:56 <EgoBot> ​["cf","bf","ps"]
03:53:54 <CakeProphet> :t filterM
03:53:55 <lambdabot> forall a (m :: * -> *). (Monad m) => (a -> m Bool) -> [a] -> m [a]
03:55:38 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print =<< filterM (const $ randomRIO (False,True)) =<< words <$> getContents
03:55:38 <EgoBot> ​Interpreter cpick installed.
03:55:45 <CakeProphet> !cpick apples oranges bananas
03:55:57 <CakeProphet> NOOOO
03:56:24 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
03:56:24 <EgoBot> ​There is already an interpreter for cpick!
03:56:28 <CakeProphet> !delinterp cpick
03:56:28 <EgoBot> ​Interpreter cpick deleted.
03:56:30 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
03:56:30 <EgoBot> ​Interpreter cpick installed.
03:56:37 <CakeProphet> !cpick apples oranges bananas
03:56:42 <EgoBot> ​["apples"]
03:56:44 <CakeProphet> !cpick apples oranges bananas
03:56:49 <EgoBot> ​["oranges","bananas"]
03:59:16 <CakeProphet> :t unwords
03:59:17 <lambdabot> [String] -> String
04:00:29 <CakeProphet> !delinterp
04:00:29 <EgoBot> ​ is not a user interpreter.
04:00:58 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print . unwords =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
04:00:58 <EgoBot> ​There is already an interpreter for cpick!
04:01:02 <CakeProphet> !delinterp pick
04:01:02 <EgoBot> ​That interpreter doesn't exist!
04:01:03 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print . unwords =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
04:01:03 <EgoBot> ​There is already an interpreter for cpick!
04:01:06 <CakeProphet> ejrwhwer
04:01:09 <CakeProphet> !delinterp cpick
04:01:09 <EgoBot> ​Interpreter cpick deleted.
04:01:11 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = print . unwords =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
04:01:11 <EgoBot> ​Interpreter cpick installed.
04:01:20 <CakeProphet> !cpick apples oranges bananas
04:01:25 <EgoBot> ​"apples bananas"
04:01:49 <CakeProphet> oh...
04:01:53 <CakeProphet> !delinterp
04:01:53 <EgoBot> ​ is not a user interpreter.
04:01:57 <CakeProphet> !delinterp cpick
04:01:58 <EgoBot> ​Interpreter cpick deleted.
04:02:08 <CakeProphet> !addinterp cpick haskell import System.Random;import Control.Monad; main = putStrLn . unwords =<< filterM (const $ randomRIO (False,True)) =<< fmap words getContents
04:02:08 <EgoBot> ​Interpreter cpick installed.
04:02:13 <CakeProphet> !cpick apples oranges bananas
04:02:18 <EgoBot> apples oranges
04:07:01 <Sgeo> calamari
04:07:04 <Sgeo> No ping :(
04:08:43 <CakeProphet> the equivalent Perl would be: $,=" "; print grep {int(rand(2))} split " " for <>;
04:12:18 <CakeProphet> I wish Haskell syntax avoided parens more often. $ is pretty nice though
04:14:09 <CakeProphet> !perl $,=" "; print "test", "test"; print "test";
04:14:10 <EgoBot> test testtest
04:14:15 <CakeProphet> !perl $,=" "; print "test", "test",; print "test";
04:14:15 <EgoBot> test testtest
04:14:19 <CakeProphet> !perl $,=" "; print "test", "test",; print ,"test";
04:14:20 <EgoBot> test test
04:14:23 <CakeProphet> :(
04:14:50 <monqy> test? test test
04:14:55 <monqy> test test test
04:15:14 <CakeProphet> > words "test\ntest"
04:15:15 <lambdabot> ["test","test"]
04:15:37 <CakeProphet> > unwords . words $ "test\ntest"
04:15:38 <lambdabot> "test test"
04:15:41 <CakeProphet> SHAME ON YOU HASKELL
04:15:44 <CakeProphet> THEY ARE NOT INVERSES.
04:15:49 <CakeProphet> baaaawwww
04:15:57 <monqy> did it ever claim they were
04:16:03 <CakeProphet> no
04:16:05 <CakeProphet> >_>
04:16:21 <CakeProphet> maybe by using un-
04:19:48 <CakeProphet> !perl $,=" "; print "test", "test"; print "","test";
04:19:48 <EgoBot> test test test
04:19:50 <CakeProphet> beautiful code
04:30:20 <CakeProphet> so uh
04:30:35 <CakeProphet> what's the different between <file.h> and <cfile> in C++?
04:30:47 <CakeProphet> cstdio vs stdio.h for example
04:31:23 <CakeProphet> I'm afraid C++ is still a huge baffling mystery to me.
04:32:10 <Sgeo> CakeProphet, I think one does one thing and one does another, not sure
04:32:21 <CakeProphet> ...ah
04:32:39 <CakeProphet> I'm inclined to think stdio.h is the C header and cstdio is the C++ header
04:32:43 <CakeProphet> but maybe they're the same.
04:32:50 <Sgeo> They're almost the same, iirc
04:33:31 <Sgeo> Same functions, but cwhatever puts the functions in std::, while whatever.h leaves them global
04:33:42 <Sgeo> Note that this is for the standard library only, probably
04:33:57 <CakeProphet> right
04:33:58 <Sgeo> http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html
04:34:43 <CakeProphet> cool so I can skip a using line. :P
04:35:26 * Sgeo shoots CakeProphet
04:36:34 <CakeProphet> what? it also means that my code will be C basically
04:36:37 <CakeProphet> which is immensely better.
04:37:07 <Sgeo> Then why not write in C?
04:37:22 <CakeProphet> I basically am at this point.
04:37:41 <Sgeo> As in, why are you using a C++ compiler?
04:38:03 <Sgeo> Also, best practices differ with some things between C and C++
04:38:44 <Sgeo> iirc, C++ forces you to cast malloc() to a void*, while in C, that's a rather bad idea
04:39:11 <Sgeo> Oh, erm, not casting to a void*, I think
04:39:15 <Sgeo> hmm, not sure
04:39:38 <Sgeo> http://stackoverflow.com/questions/605845/do-i-cast-the-result-of-malloc
04:39:54 <Sgeo> (The answer is "No" for C, and "You have to" for C++)
04:40:19 <monqy> answeR: why are you using c++
04:41:14 <CakeProphet> don't worry about it.
04:41:38 <Sgeo> Compile C with a C compiler, compile C++ with a C++ compiler.
04:41:59 <Sgeo> Although page I linked has a useful macro for if you must compile new C code with a C++ compiler
04:48:54 -!- fungot has joined.
04:49:01 <fizzie> There.
04:49:30 <fizzie> fungot: Maybe one day you should learn to restart yourself or something.
04:49:31 <fungot> fizzie: slowly a char at a time, if you're interested. seriously. especially if you're asking about
04:54:07 <CakeProphet> ^celebrate
04:54:08 <fungot> \o| |o| |o/ \m/ \m/ |o/ \o/ \o| \m/ \m/ \o| |o| |o/
04:54:08 <myndzi> | | | `\o/´ | | | `\o/´ | | |
04:54:09 <myndzi> /< >\ /< | /`\ /| |\ | /< /< |\
04:54:09 <myndzi> /`\ /'¯|_)
04:54:09 <myndzi> (_| |_) (_|
04:56:12 <shachaf> Those \m/ \m/ things are are prisoners hanging from a wall, right?
04:56:12 <myndzi> `\o/´
04:56:13 <myndzi> |
04:56:13 <myndzi> /'\
04:56:13 <myndzi> (_| |_)
04:59:44 <CakeProphet> I think it's someone jumping in the air with their fists up.
04:59:57 <CakeProphet> and out
04:59:58 <itidus21> \o/
04:59:58 <myndzi> |
04:59:58 <myndzi> /´\
05:00:31 <itidus21> shachaf: well their arms have to be up because basically
05:00:42 <itidus21> o
05:00:46 <itidus21> /|\
05:00:52 <itidus21> / \
05:01:01 <itidus21> is not possible to indicate :D
05:01:07 <shachaf> \m/ \m/ # prisoner on a rack
05:01:41 <itidus21> shachaf: ohh i see
05:02:14 <shachaf> No, that's a different thing.
05:02:25 <itidus21> had to fix my font
05:02:37 <itidus21> \m/ \m/
05:02:37 <myndzi> `\o/´
05:02:37 <myndzi> |
05:02:37 <myndzi> (_|¯´¯|_)
05:02:42 * shachaf was thinking of the cliché of... Not sure how to find a picture of it.
05:02:47 <itidus21> guh.. i aligned him wrong
05:03:16 <itidus21> keep on truckin?
05:03:38 <itidus21> nah just kidding it aint the truckin' guy :-?
05:03:55 <CakeProphet> my webcam is apparently semi-broken.
05:04:49 * itidus21 discovered just how poor i was this year when i couldn't have a digital camera even though i had the money for it on my birthday
05:06:17 * Sgeo 's webcam seems to be functional
05:07:43 <itidus21> (\webcam.webcam's cam is working) sgeo
05:08:06 <itidus21> ^ (\webcam.webcam's cam is working) (sgeo)
05:08:12 <CakeProphet> mine occasionally shows a completely green picture with black outlines
05:08:19 <CakeProphet> or will sometimes "freeze"
05:08:29 <itidus21> is that a bastardiation of LC right there? :D
05:08:38 <CakeProphet> but I can fix it by apply pressure to the top of the back of my laptop case
05:09:00 <CakeProphet> yes a terrible bastardization. whatever that means.
05:09:36 <CakeProphet> :t M.fromListWith
05:09:37 <lambdabot> forall a k. (Ord k) => (a -> a -> a) -> [(k, a)] -> M.Map k a
05:09:48 <itidus21> (\w.the cam of w is functional) (sgeo)
05:10:12 <CakeProphet> > M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:10:13 <lambdabot> fromList [(' ',6),('\'',1),('.',1),('?',1),('B',1),('W',1),('a',2),('b',1),...
05:10:26 <Sgeo> M?
05:10:33 <CakeProphet> it's short for Data.Map
05:10:42 <CakeProphet> lambdabot shorthand stuff.
05:10:51 <CakeProphet> BS is bytestring and S is set I believe.
05:11:10 <itidus21> the plan of course is that (\w.the cam of w is functional) (sgeo) becomes the cam of (sgeo) is functional
05:11:51 <CakeProphet> > sortBy (compare `on` snd) . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:11:51 <lambdabot> Couldn't match expected type `[(a, b)]'
05:11:51 <lambdabot> against inferred type `Data...
05:12:22 <CakeProphet> > sortBy (compare `on` snd) . toList . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:12:23 <lambdabot> Not in scope: `toList'
05:12:29 <CakeProphet> > sortBy (compare `on` snd) . M.toList . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:12:31 <lambdabot> [('\'',1),('.',1),('?',1),('B',1),('W',1),('b',1),('d',1),('i',1),('l',1),(...
05:12:41 <itidus21> (\wx.the x of w is functional) (sgeo) (webcam)
05:12:58 <monqy> what
05:13:06 <CakeProphet> > sortBy (flip compare `on` snd) . M.toList . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:13:08 <lambdabot> [(' ',6),('t',3),('a',2),('e',2),('h',2),('o',2),('\'',1),('.',1),('?',1),(...
05:13:10 <itidus21> you know what it means, it's perfectly valid :>
05:13:24 <Sgeo> itidus21, is as addicted to pseudolambdacalculus as I am to [censored]
05:13:44 <monqy> a good summary
05:13:50 <monqy> description
05:13:51 <monqy> thing
05:13:52 <CakeProphet> s/\[censored]/cocaine/
05:13:57 <monqy> metaplace sex
05:14:21 <itidus21> it is only a coincedence that the variables s g e and o happen to spell out sgeo
05:14:34 <CakeProphet> is there anything in Haskell that lets you specify a secondary thing to sort by...
05:15:00 <CakeProphet> like, a quick pointfree way to say "if this comparison is EQ then try this one"
05:16:06 <CakeProphet> I guess you would just use if'
05:16:45 <CakeProphet> or write your own.
05:17:14 <CakeProphet> @hoogle or
05:17:14 <lambdabot> Prelude or :: [Bool] -> Bool
05:17:15 <lambdabot> Data.Foldable or :: Foldable t => t Bool -> Bool
05:17:15 <lambdabot> Data.List or :: [Bool] -> Bool
05:17:18 <Jafet> > (LT `mappend` GT, EQ `mappend` GT)
05:17:19 <lambdabot> (LT,GT)
05:17:24 <monqy> Yes there is: a Monoid instance for Ordering. I dunno if it's standard though.
05:17:26 <monqy> yes that thing
05:17:34 <monqy> the one Jafet used
05:17:39 <itidus21> (\wx.the x of w is functional) (sgeo) (webcam) is suggestive of my shameful limitations
05:17:44 <CakeProphet> > LT `mappend` EQ
05:17:44 <lambdabot> LT
05:17:48 <CakeProphet> > EQ `mappend` EQ
05:17:49 <lambdabot> EQ
05:17:50 <CakeProphet> > EQ `mappend` GT
05:17:51 <lambdabot> GT
05:17:52 <CakeProphet> > EQ `mappend` LT
05:17:52 <lambdabot> LT
05:18:07 <Jafet> > liftM2 mappend [LT..GT] [LT..GT]
05:18:07 <lambdabot> A section must be enclosed in parentheses thus: (`LT..` GT)Not in scope: `L...
05:18:15 <CakeProphet> > mappend <$> [LT..GT] <*> [LT..GT]
05:18:15 <lambdabot> A section must be enclosed in parentheses thus: (`LT..` GT)Not in scope: `L...
05:18:18 <CakeProphet> you beat me to it...
05:18:18 <Jafet> > liftM2 mappend [LT .. GT] [LT .. GT]
05:18:19 <lambdabot> [LT,LT,LT,LT,EQ,GT,GT,GT,GT]
05:18:37 <CakeProphet> hmmm, okay.
05:18:41 <CakeProphet> that's cool.
05:18:56 <monqy> you know how to use Ordering right
05:19:07 <CakeProphet> ...how could I not know how to use Ordering?
05:19:17 <monqy> by being sgeo? i dunno
05:19:21 <monqy> does sgeo know how to use Ordering
05:19:43 -!- MDude has changed nick to MSleep.
05:20:31 <CakeProphet> monqy: no really what do you mean.
05:20:47 <monqy> what do i mean by what
05:21:08 <CakeProphet> I just don't really understand why you asked that.
05:21:29 <monqy> oh
05:21:37 <itidus21> what surprised me i suppose about #esoteric is the sheer intelligence found heer
05:21:44 <monqy> because you seemed not to know what to do???
05:21:57 <CakeProphet> I'm just bad at Haskell. :P
05:22:41 <CakeProphet> @hoogle Comparing -> Comparing -> Comparing
05:22:41 <lambdabot> Warning: Unknown type Comparing
05:22:41 <lambdabot> Prelude asTypeOf :: a -> a -> a
05:22:41 <lambdabot> Network.BufferType buf_append :: BufferOp a -> a -> a -> a
05:22:47 <CakeProphet> er
05:22:52 <itidus21> i think i expected to just find half-baked versions of BASIC
05:22:54 <CakeProphet> @hoogle Ordering -> Ordering -> Ordering
05:22:54 <lambdabot> Prelude max :: Ord a => a -> a -> a
05:22:54 <lambdabot> Prelude min :: Ord a => a -> a -> a
05:22:55 <lambdabot> Data.Ord max :: Ord a => a -> a -> a
05:23:05 <CakeProphet> ....Ordering is not Ord hoogle
05:23:27 <CakeProphet> @hoogle Ordering -> Ordering
05:23:28 <lambdabot> Prelude pred :: Enum a => a -> a
05:23:28 <lambdabot> Prelude succ :: Enum a => a -> a
05:23:28 <lambdabot> Prelude id :: a -> a
05:23:41 <CakeProphet> @src comparing
05:23:41 <lambdabot> Source not found. Listen, broccoli brains, I don't have time to listen to this trash.
05:25:05 <monqy> I'm guessing comparing f = compare `on` f
05:25:24 <CakeProphet> yeah except it doesn't use on
05:25:27 <CakeProphet> but same thing.
05:25:30 * CakeProphet just looked it up.
05:26:22 <CakeProphet> > let comparingD = flip compare `on` f in sortBy (comparingD snd `mappend` comparingD fst) . M.toList . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:26:23 <lambdabot> Couldn't match expected type `((a, a) -> a)
05:26:23 <lambdabot> ...
05:26:43 <CakeProphet> > let comparingD = (flip compare `on`) in sortBy (comparingD snd `mappend` comparingD fst) . M.toList . M.fromListWith (+) . (`zip` repeat 1) $ "What is love? Baby don't hurt me."
05:26:44 <lambdabot> [(' ',6),('t',3),('o',2),('h',2),('e',2),('a',2),('y',1),('v',1),('u',1),('...
05:27:31 <CakeProphet> there should really be something like an Ordering negation. LT -> GT, GT -> LT, EQ -> EQ
05:27:58 <CakeProphet> but maybe that wouldn't do what you'd expect for partial orders?
05:28:04 * CakeProphet doesn't understand partial orders very well.
05:30:04 <CakeProphet> but still the existing combinators make complex sorts not very terrible.
05:30:11 <CakeProphet> would be nice if it were ++ instead of mappend.
05:30:51 <monqy> pull a caleskell
05:32:19 <CakeProphet> I think we could collective improve the standard lib a bit.
05:32:31 <CakeProphet> also our Prelude should definitely be called Overture. :P
05:32:59 -!- RFKorolev has joined.
05:37:34 <RFKorolev> Good time =)
05:37:46 <monqy> hi
05:41:08 <RFKorolev> Дарова всем=)
05:41:38 <monqy> nope
05:42:59 <RFKorolev> ???
05:43:53 <monqy> help
05:47:12 <RFKorolev> you need help?=)
05:47:59 <monqy> I do not understand you. This is the area in which I need help.
05:58:44 -!- Jafet has quit (Quit: Leaving.).
06:02:48 -!- RFKorolev has left.
06:02:54 <monqy> bye
06:10:53 -!- Jafet has joined.
06:12:23 <CakeProphet> hmmm, I'm not really sure why the dictionary is necessary.
06:12:43 <CakeProphet> couldn't you compile typeclasses down into a large number of specific functions, and then use those where appropriate?
06:13:12 <CakeProphet> the only exception I can think of is existentials / rank-n types
06:13:26 -!- Gregor has quit (Ping timeout: 260 seconds).
06:15:48 -!- Gregor has joined.
06:16:15 -!- Gregor has changed nick to Guest79464.
06:18:53 <Sgeo> !
06:30:36 <CakeProphet> !
06:30:45 <shachaf> ¡
06:33:03 <Patashu> I know about the permutations, combinations, combinations with repetitions and so on. But how do I calculate the possible combinations of a state machine whos possible states in each slot depend on the previous slot? e.g. slot can be lit only if slot before it was not lit
06:34:47 <fizzie>
06:41:01 <CakeProphet> Patashu: basically you have to do each one as a special case, and then add each case together.
06:41:39 <monqy> CakeProphet: oh?
06:41:44 <Patashu> I mean a closed formular
06:41:48 <Patashu> like how there's a closed formula for fibbonaci
06:42:27 <Patashu> http://pastebin.com/QS6YHr67 here's an example
06:42:32 <Patashu> I sooort of have a closed formula
06:42:45 <fizzie> For any sequence, just compute the first 5-10 numbers by hand and feed them to OEIS. Never fails.
06:43:02 <Patashu> hahaha
06:44:14 <fizzie> (It works slightly less well when you have two parameters to vary, though.)
06:44:32 <CakeProphet> yeah no sure I understand.
06:44:34 <CakeProphet> *not
06:45:39 <CakeProphet> okay so each slot has two states and there's no adjacent ons?
06:45:43 <Patashu> yes
06:45:45 <Patashu> find combinations
06:45:57 <Patashu> it looks kiiind of like the real combinations function. but not quite
06:46:09 <CakeProphet> uh... lets see.
06:46:15 <CakeProphet> I have a feeling it will involve a lot of addition.
06:46:21 <Patashu> e.g. compare to http://upload.wikimedia.org/wikipedia/commons/thumb/6/62/Combinations_with_repetition%3B_5_multichoose_3.svg/370px-Combinations_with_repetition%3B_5_multichoose_3.svg.png
06:46:29 <CakeProphet> but maybe you can compress it into something more succinct.
06:46:45 <Patashu> hmm...
06:46:53 <CakeProphet> is there a finite number of slots?
06:47:05 <CakeProphet> ....I would assume so.
06:47:09 <Patashu> it's like a staggered version of the combination function. each extra stage with more lights enters one slot later and has one slot less than the previous one
06:47:10 <Patashu> or so
06:47:10 <CakeProphet> difficult to count combinations otherwise.
06:47:19 <Patashu> yeah, we define it over s finite slots
06:48:07 <CakeProphet> ...that's pretty complicated. :P
06:48:14 <Patashu> another function I'd like is: how many ways can I draw n distinct (separated by a gap of one or more off tiles) groups on a row of m tiles
06:49:21 <Patashu> hmm... I bet something in here will help: http://en.wikipedia.org/wiki/List_of_permutation_topics if I only knew what to read first...
06:50:22 -!- Jafet has quit (Ping timeout: 252 seconds).
06:52:14 -!- Jafet has joined.
06:58:44 <fizzie> If I hand-counted the first few right (and understood the thing), it starts with 2,3,5,8,13,20,34,55..., and curiously there are no such sequences in OEIS.
06:59:05 <Patashu> if you start it with 1 (for s = 0)
06:59:08 <Patashu> it looks like fibonacci briefly
06:59:09 <Patashu> then diverges
06:59:50 <Sgeo> Patashu, hmm, was going to say similar, but was not familiar enough with Fib to immediately recognize the divergance
07:00:13 <Patashu> wait...
07:00:17 <Patashu> I don't think you hand counted them right
07:00:18 <Patashu> let me try
07:00:30 <fizzie> "Question 3 (30): If n and k are any naturals, define h(n,k) to be the number of subsets of the set {1,...,n} of size k that do not contain two adjacent numbers. For example, h(4,2) = 3 because the relevant sets are {1,3}, {1,4}, and {2,4}. The other three subsets of size 2 contain two adjacent numbers."
07:00:48 <fizzie> It has been a question on some "CMPSCI 250: Introduction to Computation" course.
07:01:20 <fizzie> (I was just going by that example paste here.)
07:01:24 <Patashu> oh, cool
07:01:36 <Patashu> but is that something you write a program to solve?
07:01:43 <Patashu> or something you write a closed formula for?
07:01:56 <fizzie> "(c,15) Prove that h(n,k) = (n choose 2k-1) for all n and k. (Hint: Define and justify a bijection from the no-adjacent element sets of size k and all the sets of size 2k-1.) "
07:02:01 <fizzie> With solutions, http://www.cs.umass.edu/~barring/cs250f04/exams/3pracsol.html
07:02:33 <Patashu> 1 1 1 1 1 1 1 1 1 1
07:02:33 <Patashu> 1 2 3 4 5 6 7 8 9
07:02:33 <Patashu> 1 3 6 10 15 21 28
07:02:33 <Patashu> 1 4 10 20 35
07:02:51 <Patashu> looks like it goes 1 2 3 5 8 12 21 33 50 73
07:03:26 <Patashu> ty, fizzie
07:03:43 <Jafet> > let cnt n = length $ filter (all (\(x,y) -> x/=y)) $ map (ap tail zip) $ subsequences [1..n] in map cnt [1..9]
07:03:44 <lambdabot> Couldn't match expected type `a -> b' against inferred type `[a1]'
07:04:04 <fizzie> 1+5+6+1 != 12.
07:04:11 <Patashu> oh yeah, 13
07:04:11 <Patashu> derp
07:05:46 <CakeProphet> Jafet: precedence error with $ I believe.
07:05:49 <Jafet> > let cnt n = length $ filter (all (\(x,y) -> x/=y)) $ map (ap zip tail) $ subsequences [1..n] in map cnt [1..9]
07:05:50 <lambdabot> [2,4,8,16,32,64,128,256,512]
07:06:09 <Jafet> Okay, that's probably not correct.
07:06:32 <fizzie> As for the 33, are you sure that shouldn't be 34? There's one more row there, it'd be 1+7+15+10+1.
07:06:48 <Jafet> > let cnt n k = length $ filter (all (\(x,y) -> x/=y)) $ map (ap zip tail) $ filter ((==k).length) $ subsequences [1..n] in [ [ cnt n k | k <- [1..n] ] | n <- [1..8] ]
07:06:50 <lambdabot> [[1],[2,1],[3,3,1],[4,6,4,1],[5,10,10,5,1],[6,15,20,15,6,1],[7,21,35,35,21,...
07:07:12 <Jafet> Proof by lambdabot
07:07:49 <fizzie> http://oeis.org/A000045 <- Fibonacci numbers, aka "F(n+2) = number of binary sequences of length n that have no consecutive 0's. F(n+2) = number of subsets of {1,2,...,n} that contain no consecutive integers."
07:08:44 <CakeProphet> oh neat.
07:08:55 <CakeProphet> an application for fibonacci numbers. :D
07:09:05 <Patashu> woah. now THAT's cool
07:09:16 -!- Jafet has quit (Quit: Leaving.).
07:09:28 <fizzie> Good old fib: it's everywhere.
07:09:46 <Patashu> I didn't realize it was just plain old fibby
07:09:48 <Patashu> XD
07:09:51 <Patashu> crazy
07:12:05 <CakeProphet> > let count = (fibs !!) . (+2); fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in count 7
07:12:06 <lambdabot> 34
07:14:21 <CakeProphet> > let count = (fibs !!) . (+2); fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in drop 2 fibs
07:14:22 <lambdabot> [1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,177...
07:15:06 <CakeProphet> the number of permutations grows fibonaccically. :P
07:15:12 <CakeProphet> (totally a real term)
07:16:59 <Patashu> fib is exponential I believe
07:17:15 <Patashu> yeah, exponential, since it grows as fast as it is big
07:17:23 <Patashu> O(2^n) ftw!
07:17:34 <fizzie> > let count = fib . (+2); fib = floor . (+0.5) . (/ (sqrt 5)) . (phi^); phi = (1 + (sqrt 5)) / 2 in count 7
07:17:35 <lambdabot> 34
07:17:54 <fizzie> Oh noes, it was longer than the fibs !!.
07:18:08 <CakeProphet> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in zipWith (-) (map (2^) [0..]) (drop 2 fibs)
07:18:09 <lambdabot> [0,0,1,3,8,19,43,94,201,423,880,1815,3719,7582,15397,31171,62952,126891,255...
07:18:16 <Patashu> that's a fail fib function
07:18:44 <fizzie> > [1,2,3] ‼ 1 -- can you do the unicode thing
07:18:45 <lambdabot> Not in scope: `
07:18:47 <fizzie> Aw.
07:18:48 <CakeProphet> difference in number of binary total strings vs strings with no consecutive 0's
07:19:14 <CakeProphet> Patashu: what's wrong with it?
07:19:37 <fizzie> > let l ‼ i = l !! i in [1,2,3] ‼ 1
07:19:38 <lambdabot> 2
07:20:11 <monqy> > let (‼) = (!) in [1,2,3] ‼ 1
07:20:12 <lambdabot> Couldn't match expected type `GHC.Arr.Array i e'
07:20:12 <lambdabot> against inferred t...
07:20:17 <monqy> oh oops
07:20:20 <monqy> > let (‼) = (!!) in [1,2,3] ‼ 1
07:20:20 <lambdabot> 2
07:20:22 <monqy> there all better
07:21:18 <Patashu> 1+3 = 8?
07:21:33 <CakeProphet> ...uh, no? :P
07:21:39 <Patashu> hmm
07:21:46 <Patashu> oh, I see
07:21:49 <CakeProphet> ...yeah.
07:22:03 <CakeProphet> I am counting the difference
07:22:12 <CakeProphet> how many are not possible.
07:24:12 <CakeProphet> it helps to actually read code before you criticize it. kthx :P
07:24:32 <Patashu> I still can't read haskell
07:24:35 <Patashu> especially people making fibs in haskell
07:24:44 <Patashu> I know why it works, I just can't read it
07:24:46 <Patashu> it's some arcane trickery
07:24:52 <CakeProphet> 0 : 1 : zipWith fibs (tail fibs) is beautiful and easy.
07:25:33 <Patashu> I see what it's meant to do
07:25:36 <Patashu> But I try and work through it in my head
07:25:38 <Patashu> And stack overflow
07:26:28 <CakeProphet> > let fibs = 0 : 1 : zipWith fibs (tail fibs) in fibs
07:26:28 <lambdabot> Couldn't match expected type `[a]'
07:26:28 <lambdabot> against inferred type `a -> b ->...
07:26:34 <Patashu> forgot (+)
07:26:38 <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs
07:26:38 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946...
07:26:41 <CakeProphet> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs
07:26:41 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946...
07:26:43 <CakeProphet> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in tail fibs
07:26:44 <lambdabot> [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,1...
07:27:26 <CakeProphet> you have 0 : 1 : *thunk* and 1 : *thunk
07:27:29 <CakeProphet> to start with
07:27:35 <Patashu> so when I want an element of fibs I ask it if it has this element. for the first two it says yes. for the third it has to run zipwith on itself. it asks for the first and second element and gets it, delivering the third. when I ask it for the fourth, it runs it on the second and third...
07:27:37 <Patashu> I think I get it
07:27:49 <CakeProphet> yep.
07:28:00 <CakeProphet> it's laziness magic.
07:28:57 <CakeProphet> > filterM (const [True, False]) "abc"
07:28:57 <lambdabot> ["abc","ab","ac","a","bc","b","c",""]
07:29:00 <CakeProphet> do you know how this one works?
07:29:07 <Patashu> so, what you were finding is how much faster it grows than 2^
07:29:11 <Patashu> one second
07:29:13 <Patashu> I want to try something
07:29:17 <CakeProphet> how slower it grows
07:29:20 <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in zipWith (-) (map (3^) [0..]) (drop 2 fibs)
07:29:21 <lambdabot> [0,1,6,22,73,230,708,2153,6506,19594,58905,176914,531064,1593713,4781982,14...
07:29:31 <CakeProphet> 2^length == total number of binary strings of length
07:29:38 <Patashu> so 3^ grows faster than fibs?
07:29:42 <CakeProphet> yes.
07:29:47 <CakeProphet> 2^ grows faster than fibs.
07:29:48 <Patashu> right, I was thinking about it backwards
07:29:54 <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in zipWith (-) (map (1.5^) [0..]) (drop 2 fibs)
07:29:55 <lambdabot> [0.0,-0.5,-0.75,-1.625,-2.9375,-5.40625,-9.609375,-16.9140625,-29.37109375,...
07:30:01 <Patashu> so it's between 2 and 1.5, ey?
07:30:05 <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in zipWith (-) (map (1.618^) [0..]) (drop 2 fibs)
07:30:06 <lambdabot> [0.0,-0.3819999999999999,-0.38207599999999964,-0.7641989679999988,-1.146473...
07:30:13 <Patashu> yeah, about 1.618
07:30:20 <CakeProphet> and in combinatorics to get the number of possibilities in which some condition doesn't occur, you can subtract the total number by the number in which the event does occur
07:30:23 <fizzie> About phi.
07:30:26 <Patashu> ya
07:31:17 <CakeProphet> I wonder why it's Fib(n+2)
07:31:23 <CakeProphet> the +2, specifically
07:31:34 <Patashu> I don't think it needs to be?
07:31:38 <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in zipWith (-) (map (1.618^) [0..]) (fibs)
07:31:39 <lambdabot> [1.0,0.6180000000000001,1.6179240000000004,2.2358010320000012,3.85352606977...
07:31:45 <Patashu> ooo
07:31:46 <Patashu> now that's cool
07:31:48 <CakeProphet> ...er, you misunderstand.
07:31:52 <Patashu> phi^2 = phi+1, did you know?
07:31:53 <Patashu> oh
07:32:07 <CakeProphet> sure did.
07:32:11 <Patashu> okay, explain away
07:32:47 <CakeProphet> I was wondering why the number of binary strings of length n with no consecutive 0's is Fib(n+2). Specifically why you add two to the length.
07:33:07 <Patashu> it must be a consequence of numbering them differently, is all
07:33:10 <Patashu> like gamma and factorial
07:33:33 <CakeProphet> yeah I have a vague intuitive idea but I don't really know how to work it out.
07:34:56 <Patashu> Well, I mean in the sense that you can start fib as 0, 1, 1, 2 or as 1, 1, 2 or as 1, 2
07:35:03 <Patashu> Depending on what scenario it arises from
07:35:12 <Patashu> After all, the two starting values of fib are given
07:35:14 <CakeProphet> I don't think starting with 1, 2 is common.
07:35:17 <Patashu> So do you give 0,1 1,1 or 1,2?
07:35:30 <Patashu> Well, in this case apparently you start with 1,2 :O)
07:35:38 <CakeProphet> ah, yeah I see.
07:35:50 <CakeProphet> because the first two cases are 1, 2 2 :P
07:35:52 <CakeProphet> -2
07:36:58 <CakeProphet> which is kind of obvious since that's what the fibonacci sequence does...
07:37:23 <fizzie> As for "why fib", there's the obvious intuitive explanation of "to generate all suitable binary strings of length N, take either '1' followed by a string of length N-1, or '01' followed by a string of length N-2".
07:37:49 <CakeProphet> ah yes
07:37:58 <CakeProphet> and the previous strings have to follow the same rule.
07:37:59 <fizzie> (I do wonder why it's "no consecutive 0s" as opposed to "no consecutive 1s", though.)
07:38:06 <CakeProphet> makes no difference though.
07:38:09 <Patashu> no difference
07:38:21 <CakeProphet> I guess they just picked one. :P
07:38:35 <Patashu> thanks fizzie
07:40:06 <CakeProphet> combinatorics is one of those fields of math that I enjoy learning about, but don't really have a talent for.
07:40:23 <CakeProphet> it's very useful.
07:41:20 <CakeProphet> hmmm I wonder if you can extend that to strings with an arbitrary number of symbols.
07:41:43 <CakeProphet> yeah..
07:41:44 <CakeProphet> you can.
07:42:36 <CakeProphet> > let f = 0 : 3 : zipWith (+) f (tail f) in f
07:42:36 <lambdabot> [0,3,3,6,9,15,24,39,63,102,165,267,432,699,1131,1830,2961,4791,7752,12543,2...
07:42:48 <CakeProphet> I think this is ternary.
07:42:50 <CakeProphet> I think.
07:43:13 <CakeProphet> with no consecutive 0's (or whatever symbol you want)
07:43:38 <CakeProphet> hmmm, no
07:43:51 -!- Jafet has joined.
07:43:58 <Patashu> that's just fib with different start
07:44:02 <Patashu> hmm
07:44:12 <CakeProphet> there would be more than 3 for the case of length 2. You'd have 01, 10, 11, 12, 21, ...
07:44:14 <Patashu> yeah, that's not right
07:44:50 <CakeProphet> it's no consecutive 0's or 1's
07:44:52 <Patashu> recursively, you can have 1 then N-1, 2 then N-1, 01 then N-2 or 02 then N-2
07:44:54 <CakeProphet> or whichever 2 symbols you want.
07:44:55 <Patashu> oh?
07:44:56 <Patashu> hmmm
07:45:11 <Patashu> so 2 then N-1, 02 then N-2 or 12 then N-2
07:45:39 <CakeProphet> it's not f(n+2) here just f(n) I believe.
07:46:05 <CakeProphet> > let f = 0 : 1 : zipWith (+) f (tail f) in f
07:46:06 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946...
07:46:14 <CakeProphet> ah no.
07:46:28 <CakeProphet> > let f = 1 : 3 : zipWith (+) f (tail f) in f
07:46:29 <lambdabot> [1,3,4,7,11,18,29,47,76,123,199,322,521,843,1364,2207,3571,5778,9349,15127,...
07:47:30 <CakeProphet> > replicateM 2 "012"
07:47:31 <lambdabot> ["00","01","02","10","11","12","20","21","22"]
07:47:40 <CakeProphet> nah
07:55:36 <CakeProphet> > let f = 1 : 3 : 8 : zipWith3 (+) f (tail f) (tail (tail f)) in f
07:55:37 <lambdabot> Occurs check: cannot construct the infinite type: c = c -> t
07:56:47 <CakeProphet> @pl (\x y z -> x+y+z)
07:56:47 <lambdabot> ((+) .) . (+)
07:57:00 <CakeProphet> > let f = 1 : 3 : 8 : zipWith3 ((+) :. (+)) f (tail f) (tail (tail f)) in f
07:57:01 <lambdabot> Not in scope: data constructor `:.'
07:57:07 <CakeProphet> > let f = 1 : 3 : 8 : zipWith3 ((+) .: (+)) f (tail f) (tail (tail f)) in f
07:57:08 <lambdabot> [1,3,8,12,23,43,78,144,265,487,896,1648,3031,5575,10254,18860,34689,63803,1...
07:57:33 <CakeProphet> ?
07:58:01 <CakeProphet> > replicateM 3 "abc"
07:58:01 <lambdabot> ["aaa","aab","aac","aba","abb","abc","aca","acb","acc","baa","bab","bac","b...
07:58:06 <CakeProphet> > replicateM 3 "012"
07:58:06 <lambdabot> ["000","001","002","010","011","012","020","021","022","100","101","102","1...
07:58:41 <CakeProphet> > drop 8 $ replicateM 3 "012"
07:58:41 <lambdabot> ["022","100","101","102","110","111","112","120","121","122","200","201","2...
07:58:47 <CakeProphet> > drop 7 $ replicateM 3 "012"
07:58:48 <lambdabot> ["021","022","100","101","102","110","111","112","120","121","122","200","2...
07:58:51 <CakeProphet> > drop 6 $ replicateM 3 "012"
07:58:52 <lambdabot> ["020","021","022","100","101","102","110","111","112","120","121","122","2...
07:59:38 <CakeProphet> > drop 11 $ replicateM 3 "012"
07:59:39 <lambdabot> ["102","110","111","112","120","121","122","200","201","202","210","211","2...
08:03:31 <CakeProphet> yeah I can't figure out how to do that.
08:08:01 <CakeProphet> the first numbers in the sequence are 1, 3, 8
08:10:17 <fizzie> For an alphabet of K symbols with a single "no consecutive 0s", you could construct all the N-length valid strings f(N) = "X".f(N-1) | "0X".f(N-1) where X is one out of the K-1 non-'0' symbols; so the count n(N) = (K-1)*n(N-1) + (K-1)*n(N-2) = (K-1)*(n(N-1) + n(N-2)).
08:10:27 <fizzie> In this case, 8 = 2*(1+3).
08:10:42 <CakeProphet> ah
08:11:19 <fizzie> http://oeis.org/A028859
08:11:25 <fizzie> "Number of words of length n without adjacent 0's from the alphabet {0,1,2}."
08:13:52 <Patashu> wow, cool
08:14:04 <CakeProphet> > let f k = 1 : k : zipWith ((+) `on` (*(k-1))) (f k) (tail (f k)) in f 3
08:14:08 <lambdabot> mueval-core: Time limit exceeded
08:14:10 <CakeProphet> erm
08:15:16 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 3
08:15:17 <lambdabot> [1,3,8,22,60,164,448,1224,3344,9136,24960,68192,186304,508992,1390592,37991...
08:15:29 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 4
08:15:30 <lambdabot> [1,4,15,57,216,819,3105,11772,44631,169209,641520,2432187,9221121,34959924,...
08:15:32 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 5
08:15:33 <lambdabot> [1,5,24,116,560,2704,13056,63040,304384,1469696,7096320,34264064,165441536,...
08:15:33 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 6
08:15:34 <lambdabot> [1,6,35,205,1200,7025,41125,240750,1409375,8250625,48300000,282753125,16552...
08:15:35 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 7
08:15:36 <lambdabot> [1,7,48,330,2268,15588,107136,736344,5060880,34783344,239065344,1643092128,...
08:16:08 <CakeProphet> wheeee
08:17:04 <CakeProphet> > let f k = let a = 1 : k : zipWith ((+) `on` (*(k-1))) a (tail a) in a in f 127
08:17:05 <lambdabot> [1,127,16128,2048130,260096508,33030224388,4194580432896,532678942817784,67...
08:17:25 <fizzie> http://oeis.org/A125145 "Number of aa-avoiding words of length n on the alphabet {a,b,c,d}." http://oeis.org/A086347 "Number of aa-avoiding words of length n on alphabet {a,b,c,d,e}."
08:18:01 <CakeProphet> so yeah, looks to be correct.
08:19:10 <fizzie> And http://oeis.org/A180033 is for 6, except it's not listed in the comments; but it's "a(n) = f*a(n-1) + 5*a(n-2) with a(0) = 1 and a(1) = 6". (The official description is "eight white queens and one red queen on a 3 X 3 chessboard".)
08:19:49 <CakeProphet> f*a(n-1)?
08:19:52 <CakeProphet> what is f?
08:20:00 <fizzie> 5. Sorry. Didn't copy-pasta.
08:20:03 <CakeProphet> ah
08:20:30 <CakeProphet> quick let's do something interesting with this knowledge.
08:20:55 <fizzie> In general, the generating function seems to be (1+x)/(1 - (k-1)x - (k-1)x^2) for all of these. I'm sure a real combinatricist could immediately tell why's that.
08:24:33 -!- itidus21 has left ("Leaving").
08:52:31 <CakeProphet> hookahzeit
08:53:01 <CakeProphet> a programming language with word-compounding would be interesting.
08:56:02 <monqy> eh?
08:56:20 <CakeProphet> monqy: ALWAYS SO CONFUSED
08:56:21 <CakeProphet> WHY
08:56:25 <monqy> why
08:57:34 <CakeProphet> !addinterp monqy haskell import Data.Char;import Control.Monad putStrLn =<< mapM toLower getContents
08:57:34 <EgoBot> ​Interpreter monqy installed.
08:57:38 <CakeProphet> !monqy WHY
08:57:40 -!- cheater has quit (Ping timeout: 260 seconds).
08:58:20 <monqy> why
08:58:23 <CakeProphet> :t mapM
08:58:24 <lambdabot> forall a (m :: * -> *) b. (Monad m) => (a -> m b) -> [a] -> m [b]
08:58:29 <CakeProphet> oh..
08:58:38 <CakeProphet> !addinterp monqy haskell import Data.Char;import Control.Monad putStrLn =<< fmap toLower getContents
08:58:38 <EgoBot> ​There is already an interpreter for monqy!
08:58:41 <CakeProphet> !delinterp monqy
08:58:41 <EgoBot> ​Interpreter monqy deleted.
08:58:41 <CakeProphet> !addinterp monqy haskell import Data.Char;import Control.Monad putStrLn =<< fmap toLower getContents
08:58:41 <EgoBot> ​Interpreter monqy installed.
08:58:48 <CakeProphet> !monqy WHY
08:58:57 <monqy> you want fmap.fmap i think
08:59:14 <CakeProphet> !delinterp monqy
08:59:14 <EgoBot> ​Interpreter monqy deleted.
08:59:26 <monqy> fmap (fmap toLower) getContents is the idea
08:59:36 <CakeProphet> !addinterp monqy perl print lc while <>
08:59:36 <EgoBot> ​Interpreter monqy installed.
08:59:40 <CakeProphet> !monqy WHY
08:59:40 <EgoBot> why
08:59:42 <monqy> ;_;
08:59:48 <monqy> besides
09:00:04 <monqy> lowercasing everything isn't quite an accurate representation, especially when I uppercase
09:00:16 <monqy> sometimes I remove puntuation, sometimes I retain it, what now??????
09:00:22 <CakeProphet> right but it's an interpreter to help you with your need to lowercase things.
09:00:30 <monqy> i do not require it
09:00:35 <CakeProphet> well it's to help me with it
09:00:47 <CakeProphet> !monqy SO THERE
09:00:48 <EgoBot> so there
09:00:52 <monqy> so there
09:01:29 <CakeProphet> as it turns out bananas foster and caramel frappucino are an excellent combination.
09:01:49 -!- kmc has quit (Quit: Leaving).
09:01:53 <CakeProphet> monqy: perhaps later it can be extended to randomly select one of multiple common cases.
09:02:06 <monqy> it will never work
09:02:18 <monqy> if the channel were not +c I'd be making extensive use of bold and underline as well
09:02:29 <CakeProphet> evil.
09:02:32 <CakeProphet> __evil__
09:02:35 <CakeProphet> _evil_
09:02:44 <CakeProphet> irssi underlines _evil_
09:02:55 <monqy> _not if there are multiple words_
09:02:55 <CakeProphet> *evil*
09:02:59 <CakeProphet> right
09:03:03 <monqy> also it's ugly
09:03:11 <CakeProphet> _a_b_
09:03:14 <CakeProphet> _a_ _b_
09:03:19 <CakeProphet> _fuck_ _you_
09:03:41 <monqy> :(
09:04:39 <CakeProphet> !addinterp irssi perl print s/\b/_/r while <>
09:04:39 <EgoBot> ​Interpreter irssi installed.
09:04:42 <CakeProphet> !irssi fuck you
09:04:43 <EgoBot> Bareword found where operator expected at /tmp/input.5480 line 1, near "s/\b/_/r"
09:04:58 <CakeProphet> um
09:05:03 <monqy> ~perl~
09:05:12 <monqy> in all its glory
09:06:56 <CakeProphet> ...I don't really understand the error.
09:07:07 <CakeProphet> ... /r is totally a thing.
09:08:08 <CakeProphet> !delinterp irssi
09:08:08 <EgoBot> ​Interpreter irssi deleted.
09:08:16 <CakeProphet> !addinterp irssi perl print $_ =~ s/\b/_/r while <>
09:08:16 <EgoBot> ​Interpreter irssi installed.
09:08:20 <CakeProphet> !irssi fuck you
09:08:20 <EgoBot> Bareword found where operator expected at /tmp/input.5834 line 1, near "s/\b/_/r"
09:08:23 <CakeProphet> ...wat
09:08:25 <CakeProphet> lies.
09:08:29 -!- nooga has joined.
09:08:30 <CakeProphet> !delinterp irssi
09:08:30 <EgoBot> ​Interpreter irssi deleted.
09:09:09 <CakeProphet> !addinterp irssi perl print ($_ =~ s/\b/_/r) while <>
09:09:09 <EgoBot> ​Interpreter irssi installed.
09:09:12 <CakeProphet> !irssi aerhiwurhuiwer weoirjiouwehr
09:09:13 <EgoBot> Bareword found where operator expected at /tmp/input.6108 line 1, near "s/\b/_/r"
09:09:20 <CakeProphet> !delinterp irssi
09:09:20 <EgoBot> ​Interpreter irssi deleted.
09:09:40 <CakeProphet> !perl $_="what?"; print s/what?/???/r
09:09:40 <EgoBot> Bareword found where operator expected at /tmp/input.6342 line 1, near "s/what?/???/r"
09:09:42 <Deewiant> CakeProphet: It doesn't like the /r
09:09:45 <CakeProphet> yes I understand
09:09:48 <CakeProphet> but... not why.
09:10:40 <CakeProphet> /r is a non-destructive substitute.
09:11:34 <fizzie> It was also added in some post-5.10 version, wasn't it?
09:11:39 <Deewiant> Added in what version?
09:11:40 <Deewiant> Right
09:12:28 <fizzie> 5.14, I think.
09:13:00 <fizzie> 5.12 manual says "s/PATTERN/REPLACEMENT/msixpogce"; 5.14 manual says "s/PATTERN/REPLACEMENT/msixpodualgcer".
09:13:07 <fizzie> (That's quite a list of modes.)
09:13:36 <Deewiant> 5.8.4 manual says s/PATTERN/REPLACEMENT/egimosx
09:13:55 <CakeProphet> !perl use 5.12; $_="what?"; print s/what?/???/r
09:13:55 <EgoBot> Perl v5.120.0 required (did you mean v5.12.0?)--this is only v5.10.1, stopped at /tmp/input.6650 line 1.
09:14:13 <fizzie> 5.12 won't help if it was introduced in 5.14.
09:14:23 <CakeProphet> right I was just checking the version.
09:14:49 <CakeProphet> use 5.12 is a version check not a "magically use this version instead".
09:14:55 <CakeProphet> even though that's kind of what it suggests that it would do.
09:15:36 <fizzie> Well, sure, but I would have thought it'd make more sense to check for 5.14 directly. But w/e.
09:15:58 <CakeProphet> yeah I just glanced up to get a version number but didn't check which one was right. :P
09:16:54 <CakeProphet> I'd imagine there's some version variable somewhere
09:17:05 <CakeProphet> !perl print __VERSION__
09:17:21 <fizzie> !perl print $^V
09:17:21 <nooga> perl
09:17:21 <EgoBot> v5.10.1
09:17:27 <CakeProphet> ah
09:17:47 <CakeProphet> yeah one day I'm going to go memorize all of those global variables.
09:17:50 <fizzie> (Also $PERL_VERSION, but $^V is definitely more perly.)
09:17:51 <CakeProphet> (Note: not really)
09:17:57 <fizzie> !perl print $]
09:17:57 <EgoBot> 5.010001
09:18:02 <fizzie> Yes, that's also better.
09:18:08 <fizzie> At least it's punctuation-only.
09:18:11 <CakeProphet> what, why ]
09:18:30 <fizzie> "Mnemonic: Is this version of perl in the right bracket?"
09:18:36 <fizzie> Of course.
09:18:45 <CakeProphet> !perl $[=100; print (1,2,3)[101]
09:18:46 <EgoBot> syntax error at /tmp/input.7119 line 1, near ")["
09:18:51 <CakeProphet> !perl $[=100; print ((1,2,3)[101])
09:18:52 <EgoBot> 2
09:18:54 <CakeProphet> bah stupid stupid stupid
09:18:58 <Deewiant> Of those, only $] works in my 5.8.4
09:19:11 <CakeProphet> I hate that it cannot parse list_literal[index]
09:19:15 <fizzie> Deewiant: Weird; the $] docs say "Deprecated in Perl 5.6".
09:19:17 <CakeProphet> without () around the whole thing
09:19:44 <fizzie> "This variable [$^V] first appeared in perl 5.6.0; earlier versions of perl will see an undefined value. Before perl 5.10.0 $^V was represented as a v-string."
09:20:10 <CakeProphet> sounds like checking versions without the use pragma is kind of a pain.
09:21:06 <fizzie> Perl 5.12 deprecates $[, incidentally.
09:21:15 <CakeProphet> it is kind of terrible, yes.
09:21:27 <Deewiant> Oh no, it works
09:21:31 <Deewiant> It just prints in binary
09:21:38 <Deewiant> 0x05 0x08 0x04
09:21:50 <fizzie> Deewiant: Yes, well, it's a v-string pre-5.10, like the above says.
09:22:04 <Deewiant> As if I should know what a v-string is.
09:22:05 <CakeProphet> $[ is a nice feature, but ends up breaking things that aren't coded to use it (read: most code out there)
09:22:23 <fizzie> (s)printf's "%vd" conversion can make a string out of it.
09:22:52 <CakeProphet> I believe s?printf is a bit more perly. :P
09:22:53 <fizzie> !perl printf "%vd\n", v5.8.4
09:22:53 <EgoBot> 5.8.4
09:22:54 <Deewiant> So it can.
09:24:28 <fizzie> "Note that since Perl 5.8.1 the single-number v-strings (like v65) are not v-strings before the => operator (which is usually used to separate a hash key from a hash value); instead they are interpreted as literal strings ('v65'). They were v-strings from Perl 5.6.0 to Perl 5.8.0, but that caused more confusion and breakage than good. Multi-number v-strings like v65.66 and 65.66.67 continue to be v-strings always."
09:24:32 <fizzie> Perl. <3
09:24:50 <CakeProphet> when people write array-handling code they usually just put explicit zeroes instead of $[ thus... $[ would tend to break code
09:24:53 <CakeProphet> if anyone actually used it.
09:27:39 -!- sebbu has quit (Read error: Connection reset by peer).
09:28:03 <CakeProphet> I find it kind of hilarious that things like $[ and $/ and $\ are variable names...
09:28:05 -!- sebbu has joined.
09:28:05 -!- sebbu has quit (Changing host).
09:28:05 -!- sebbu has joined.
09:28:56 <CakeProphet> !perl print ($2mice = "2 mice")
09:28:56 <EgoBot> Bareword found where operator expected at /tmp/input.7994 line 1, near "$2mice"
09:29:03 <CakeProphet> waaaah
09:29:28 <CakeProphet> that is totally parseable.
09:29:33 <fizzie> !perl $; = " - "; %h = (); $h{"the", "best", "way", "to", "join", "strings", "with", "a", "delimiter?"} = 42; print keys %h;
09:29:33 <EgoBot> the - best - way - to - join - strings - with - a - delimiter?
09:29:54 <fizzie> "Mnemonic: comma (the syntactic subscript separator) is a semi-semicolon."
09:30:14 <CakeProphet> ...wat
09:30:17 <CakeProphet> lol
09:30:24 <CakeProphet> what a weird thing to have.
09:30:58 <CakeProphet> perl is definitely an esolang.
09:31:21 <fizzie> It's the multidimensional array fakery thing before you could conveniently make arrays-of-arrayrefs things.
09:31:38 <CakeProphet> oh right, that used to be a thing that perl couldn't do.
09:32:15 <Patashu> did you guys ever figure out the answer for no aa or bb on {abc}?
09:33:05 <fizzie> $< and $> are the UID and EUID of the process, and you can do "$< = $>;" to set uid to euid, or "($<,$>) = ($>,$<);" to swap uid/euid.
09:33:09 <CakeProphet> I would remember $; as "the other comma thing that isn't $,"
09:34:28 <CakeProphet> !perl print $^O
09:34:28 <EgoBot> linux
09:34:36 <CakeProphet> helpful
09:35:20 <CakeProphet> !perl $^O = "Win32"; print $^O
09:35:21 <EgoBot> Win32
09:35:33 <CakeProphet> hey look guys perl is a Windows emulator.
09:38:23 <fizzie> Strings S(L) of length L with no aa or bb on {abc} you could make as "a[bc]".S(L-2) | "b[ac]".S(L-2) | "c".S(L-1); so n(L) = 4*n(L-2) + n(L-1), n(0) = 1, n(1) = 3. That gives 1,3,7,19,47,123,311,803,2047,5259,13447,... seeming to match A026581.
09:38:46 <fizzie> Or no, that's not exactly right; it needs more complication for "ab".
09:39:20 <CakeProphet> hmmm what's this notation you're using.
09:39:31 <fizzie> Nothing official.
09:39:36 <CakeProphet> oh.
09:39:42 <fizzie> It would be clumsy to write as proper sets.
09:40:06 <CakeProphet> so it's like pseudo-regexp?
09:40:24 <fizzie> Pseudo-regexp-cfg, maybe.
09:40:28 <fizzie> With the | thing.
09:40:39 <fizzie> Well, I guess that's still regex.
09:40:45 <fizzie> (Too.)
09:41:06 <CakeProphet> I've got a partially written spec for a programming language that kind of resembles that notation is why I ask.
09:41:20 <CakeProphet> except things in "" match literals and not regexp
09:41:51 <CakeProphet> it's a regexp programming language of sorts.
09:43:58 <CakeProphet> all of the expressions have return values based on the input string. So you write captures as variable assignments. x = "a"*
09:45:03 -!- derdon has joined.
09:45:08 <CakeProphet> * concatenates the string result of its operand and sums the numeric results, which works out nicely.
09:46:00 <CakeProphet> it's the way perl regex should work. :D
09:47:28 <CakeProphet> I just need to a) finish the other details b) write an interpreter c) eventually try to compile it and make it efficient
09:48:32 <Patashu> I figured out that it's start 1,3,7 and then fib(n-1)+2*fib(n-2)+fib(n-3)
09:48:35 <Patashu> for no aa, bb in abc
09:48:38 <Patashu> I don't know WHY though
09:48:43 <Patashu> length 0: (1)
09:48:44 <Patashu> length 1: a, b, c (3)
09:48:44 <Patashu> length 2: ab, ba, ac, ca, bc, cb, cc (7)
09:48:44 <Patashu> length 3: c before all lengths of 2 or (ac or bc) before all lengths of 1 or ??? before all lengths of 0
09:48:44 <Patashu> what is ???
09:48:53 <fizzie> S(L) = "c".S(L-1) | "ac".S(L-2) | "bc".S(L-2) | "ab".S_a(L-2) | "ba".S_b(L-2); S_a(L) = "b".S_b(L-1) | "c".S(L-1); S_b(L) = "a".S_a(L-1) | "c".S(L-1); n(L) = n(L-1) + 2*n(L-2) + 2*n'(L-2); n'(L) = n'(L-1)+n(L-1).
09:49:00 <fizzie> > let n 0 = 1; n 1 = 3; n l = n (l-1) + (2 * (n (l-2))) + (2 * (n' (l-2))); n' 0 = 1; n' 1 = 2; n' l = n' (l-1) + n (l-1) in take 20 $ n <$> [0..]
09:49:01 <lambdabot> [1,3,7,17,41,99,239,577,1393,3363,8119,19601,47321,114243,275807,665857,160...
09:49:07 <fizzie> I may have easily screwed that up.
09:49:31 <Patashu> that's wrong
09:49:37 <Patashu> it goes 1 3 7 14 31
09:50:27 <Patashu> hmm ,wait, no
09:50:30 <Patashu> I'm mixing two sequences up now
09:51:10 <Patashu> XD
09:52:12 <Patashu> I either want to find out no aa, bb in abc OR groups(X,n) which tells you how many ways you can make X separated lines of on bulbs in n off bulbs, which I could then do *2^X on for all the possible ways of starting alternating strings
09:52:38 <Patashu> sum X from 0 to inf of groups(X,n) is that sequence 1 3 7 14 31
09:52:44 <Patashu> no aa, bb in abc will be different
09:53:14 <Patashu> a specific groups(X,n) is a specific function in the triangular number series - tri, tetra, four-d triangle, etc etc, each staggered by 2
09:53:19 <CakeProphet> > let f n = length . filter (all ((a,b) a /= b) . ap zip tail) $ replicateM n "abc" in map f [0..]
09:53:20 <lambdabot> Couldn't match expected type `t -> a'
09:53:20 <lambdabot> against inferred type `(Simpl...
09:53:30 <CakeProphet> > let f n = length . filter (all ((a,b) -> a /= b) . ap zip tail) $ replicateM n "abc" in map f [0..]
09:53:31 <lambdabot> Pattern syntax in expression context: (a, b) -> a /= b
09:53:35 <CakeProphet> bah
09:53:39 <CakeProphet> > let f n = length . filter (all (\(a,b) -> a /= b) . ap zip tail) $ replicateM n "abc" in map f [0..]
09:53:43 <lambdabot> mueval-core: Time limit exceeded
09:54:00 <CakeProphet> > let f n = length . filter (not . any (\(a,b) -> a == b) . ap zip tail) $ replicateM n "abc" in map f [0..]
09:54:04 <lambdabot> mueval-core: Time limit exceeded
09:54:23 <fizzie> abab abac abca abcb abcc acab acac acba acbc acca accb accc baba babc baca bacb bacc bcab bcac bcba bcbc bcca bccb bccc caba cabc caca cacb cacc cbab cbac cbca cbcb cbcc ccab ccac ccba ccbc ccca cccb cccc; that's quite many already.
09:54:26 <CakeProphet> that's not quite right though.
09:55:59 <Patashu> > let f n = length . filter (not . any (\(a,b) -> a == b) . ap zip tail) $ replicateM n "abc" in f 2
09:56:01 <lambdabot> 6
09:56:12 <Patashu> > let f n = filter (not . any (\(a,b) -> a == b) . ap zip tail) $ replicateM n "abc" in f 2
09:56:13 <lambdabot> ["ab","ac","ba","bc","ca","cb"]
09:56:16 <Patashu> it's missing cc
09:56:20 <Patashu> oh, you know though
09:56:40 <Patashu> > let f n = filter (not . any (\(a,b) -> a == b or a == 'c') . ap zip tail) $ replicateM n "abc" in f 2
09:56:41 <lambdabot> Precedence parsing error
09:56:41 <lambdabot> cannot mix `GHC.Classes.==' [infix 4] and `GH...
09:56:44 <Patashu> > let f n = filter (not . any (\(a,b) -> a == b || a == 'c') . ap zip tail) $ replicateM n "abc" in f 2
09:56:45 <lambdabot> ["ab","ac","ba","bc"]
09:56:51 <Patashu> oh derp
09:56:57 <Patashu> > let f n = filter (not . any (\(a,b) -> a == b && a != 'c') . ap zip tail) $ replicateM n "abc" in f 2
09:56:58 <lambdabot> Not in scope: `!='
09:57:06 <Patashu> really?
09:57:16 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb") . ap zipWith (\x y -> [x,y]) tail) $ replicateM n "abc" in f 4
09:57:16 <lambdabot> <no location info>: parse error on input `in'
09:58:34 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap zipWith (\x y -> [x,y]) tail) $ replicateM n "abc" in f 4
09:58:35 <lambdabot> The lambda expression `\ x y -> ...' has two arguments,
09:58:35 <lambdabot> but its type `(a -...
09:59:00 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in f 4
09:59:01 <lambdabot> 41
09:59:03 <CakeProphet> parenthesese hell lol
09:59:07 <CakeProphet> errtyjierjtioj
09:59:11 <Patashu> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in f 2
09:59:12 <lambdabot> 7
09:59:13 <Patashu> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in f 3
09:59:15 <lambdabot> 17
09:59:18 <Patashu> seems right to me
09:59:26 <Patashu> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in map f [0..10]
09:59:28 <lambdabot> [1,3,7,17,41,99,239,577,1393,3363,8119]
09:59:45 <Patashu> ah, my mistake. your earlier creation was right, fizzie
09:59:51 <Patashu> just not for what I was solving
10:00:26 <CakeProphet> @pl (\x y -> [x,y])
10:00:26 <lambdabot> (. return) . (:)
10:00:44 <Patashu> now, how to prove that...
10:00:59 <fizzie> > let v 0 = [""]; v 1 = ["a","b","c"]; v n = (("c"++) <$> v (n-1)) ++ (("ac"++) <$> v (n-2)) ++ (("bc"++) <$> v (n-2)) ++ (("ab"++) <$> vb (n-2)) ++ (("ba"++) <$> va (n-2)); va 0 = [""]; va n = (("b"++) <$> vb (n-1)) ++ (("c"++) <$> v (n-1)); vb 0 = [""]; vb n = (("a"++) <$> va (n-1)) ++ (("c"++) <$> v (n-1)) in length $ v 4
10:01:01 <lambdabot> 41
10:01:07 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (return .: (:)) tail) $ replicateM n "abc" in f 4
10:01:08 <lambdabot> <no location info>: parse error on input `in'
10:01:15 <Patashu> > 17+7*3+3
10:01:16 <lambdabot> 41
10:01:23 <fizzie> (That's the construction directly translated.)
10:01:23 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (return .: (:))) tail) $ replicateM n "abc" in f 4
10:01:24 <lambdabot> Couldn't match expected type `GHC.Types.Char'
10:01:24 <lambdabot> against inferred type...
10:01:26 <CakeProphet> kahseiuhwseurhwuerh
10:01:28 <Patashu> > 99+17*3+7
10:01:29 <lambdabot> 157
10:01:32 <Patashu> wait
10:01:35 <CakeProphet> > let f n = length . filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith ((:) .: return)) tail) $ replicateM n "abc" in f 4
10:01:36 <Patashu> > 99+41*3+17
10:01:36 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
10:01:36 <lambdabot> against inferred ty...
10:01:37 <lambdabot> 239
10:01:43 <Patashu> yeah, that's the spot
10:01:43 <Patashu> :)
10:02:11 <CakeProphet> Patashu: oh btw != is /=
10:02:14 <Patashu> ah ty
10:02:16 <CakeProphet> maybe you caught that.
10:02:16 <CakeProphet> oh
10:02:17 <CakeProphet> okay.
10:02:26 <CakeProphet> yeah it threw me off for a while.
10:03:49 <CakeProphet> fizzie: also that code is crazy.
10:05:01 <Patashu> Initial conditions:
10:05:01 <Patashu> length 0: (1)
10:05:01 <Patashu> length 1: a b or c (3)
10:05:01 <Patashu> length 2: ab, ba, ac, ca, bc, cb, cc (7)
10:05:01 <Patashu> Recurrence is f(n-1)+f(n-2)*3+f(n-3):
10:05:02 <Patashu> length 3: c + string of length 2 (7) or ac or bc or ?? + string of length 1 (3*3 = 9) or ??? + string of length 0 (1) (= 17)
10:05:05 <Patashu> help me - what are ?? and ???
10:05:28 <CakeProphet> !wacro
10:05:29 <EgoBot> HIORTCAD
10:05:33 <monqy> bad
10:05:37 <CakeProphet> Patashu: HIORTCAD
10:05:40 <Patashu> oh
10:05:40 <monqy> bad
10:05:48 <fizzie> I don't know what you're looking for here.
10:05:56 <CakeProphet> monqy just stalks around and waits for me to use !wacro
10:05:58 <monqy> hiortcad is better than most though
10:05:59 <CakeProphet> I think he has it set to ping.
10:06:01 <Patashu> I'm trying to construct the reasoning behind the recurrence relationship
10:06:02 <Patashu> like when you said
10:06:05 <Patashu> Proof: For a length m, we can either add a 0 before all all lengths of m-1 or a 10 before all lengths of m-2.
10:06:10 <Patashu> I want the Proof: for no aa no bb in abc
10:07:19 <Patashu> > let f n = filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in f 3
10:07:20 <lambdabot> ["aba","abc","aca","acb","acc","bab","bac","bca","bcb","bcc","cab","cac","c...
10:07:35 <Patashu> > let f n = filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in take 10 f 3
10:07:35 <lambdabot> Couldn't match expected type `[a]'
10:07:36 <lambdabot> against inferred type `GHC.Types...
10:07:43 <Patashu> > let f n = filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in take 10 (f 3)
10:07:44 <lambdabot> ["aba","abc","aca","acb","acc","bab","bac","bca","bcb","bcc"]
10:07:48 <Patashu> > let f n = filter (all (\x -> not (x == "aa" || x == "bb")) . ap (zipWith (\x y -> [x,y])) tail) $ replicateM n "abc" in drop 10 (f 3)
10:07:49 <lambdabot> ["cab","cac","cba","cbc","cca","ccb","ccc"]
10:08:19 <CakeProphet> could reduce the condition to its && and /= version FOR GREATER CLARITY OF EXPRESSION
10:08:29 <Patashu> lol
10:08:35 <CakeProphet> and (return .) . (:)
10:08:39 <CakeProphet> for the zipWith argument
10:08:57 <CakeProphet> :t return .: (:)
10:08:58 <lambdabot> forall (m :: * -> *) a. (Monad m) => a -> [a] -> m [a]
10:09:04 <CakeProphet> or that one
10:10:09 <CakeProphet> it would be neat to have an operator that was $ but with greater precedence than spaces.
10:10:31 <CakeProphet> I'll call it... $$
10:11:06 <CakeProphet> well, no that wouldn't help.
10:11:25 <fizzie> > let f1 0 = 1; f1 1 = 3; f1 2 = 7; f1 n = f1 (n-1) + 3 * f1 (n-2) + f1 (n-3); f2 0 = 1; f2 1 = 3; f2 n = 2 * f2 (n-1) + f2 (n-2) in (f1 &&& f2) <$> [0..9]
10:11:26 <lambdabot> [(1,1),(3,3),(7,7),(17,17),(41,41),(99,99),(239,239),(577,577),(1393,1393),...
10:11:33 <fizzie> Those two certainly seem to be the same thing.
10:11:45 <fizzie> So f(n) = 2f(n-1) + f(n-2).
10:11:46 <monqy> CakeProphet: a fancy circumfix operator i'm naming right now (...)
10:11:59 <CakeProphet> you could say ap zipWith $$ (return .: (:)) tail
10:12:07 <CakeProphet> and it would in no way be horrible.
10:12:15 <monqy> actually it'd be awful
10:12:23 <monqy> ap (zipwith $ return .: (:)) tail
10:12:29 <monqy> beautiful
10:12:31 <monqy> or even better
10:12:37 <monqy> ap (zipwith (return .: (:))) tail
10:12:42 <CakeProphet> I just like avoid () when possible. But I agree that is not the correct way.
10:13:00 <CakeProphet> s/when possible/ when its clearer/
10:13:04 <monqy> parentheses are the best infix operators are the worst
10:13:05 <Patashu> hmm...
10:13:18 <Patashu> > 7*2+3
10:13:18 <lambdabot> 17
10:13:21 <Patashu> > 17*2+7
10:13:22 <lambdabot> 41
10:13:22 <Patashu> wow
10:13:26 <Patashu> ok, that one works better for me
10:14:21 <CakeProphet> monqy: you must not like Haskell very much then.
10:14:33 <monqy> CakeProphet: what makes you say that?
10:14:39 <CakeProphet> because there is infix everywhere
10:14:53 <monqy> haskell is okay
10:15:08 <monqy> or even good
10:17:52 <fizzie> Patashu: Given the simpler f(n) = 2f(n-1) + f(n-2) you can just substitute in the latter to go: f(n) = 2*(2f(n-2) + f(n-3)) + f(n-2) = 5f(n-2) + 2f(n-3) = 3f(n-2) + f(n-3) + 2f(n-2) + f(n-3) = 3f(n-2) + f(n-3) + f(n-1).
10:18:06 -!- adam__ has joined.
10:18:06 <Patashu> Yeah, I figured something like that
10:18:10 <Patashu> Ok, here's my 'logical' interpretation
10:18:11 <Patashu> Initial conditions:
10:18:11 <Patashu> length 0: (1)
10:18:11 <Patashu> length 1: a b or c (3)
10:18:11 <Patashu> Recurrence is 2*f(n-1)+f(n-2):
10:18:11 <Patashu> length 2: opposite two letters (ab before c, ac before b, bc before a) before all strings of length 1 (3*2) OR cc before strings of length 0 (1) (=7) (ab, ac, ba, bc, ca, cb, cc)
10:18:12 <Patashu> length 3: opposite two letters before all strings of length 2 (7*2) OR cc before strings of length 1 (3) (=17)
10:18:12 <Patashu> length 4: opposite two letters before all strings of length 3 (17*2) OR cc before strings of length 2 (7) (=41)
10:18:13 <Patashu> etc
10:18:13 <Patashu> The recurrence covers all 'safe' ways before something that might have an unsafe letter, and then does all ccs by itself looking two back.
10:18:23 <adam__> why is there no postfix Haskell translator thing.
10:18:50 -!- CakeProphet has quit (Disconnected by services).
10:18:55 -!- adam__ has changed nick to CakeProphet.
10:18:59 <CakeProphet> EGADS MY REAL NAME HAS BEEN EXPOSED.
10:19:11 <CakeProphet> !delinterp monqy
10:19:12 <EgoBot> ​Interpreter monqy deleted.
10:19:24 <monqy> "exposed"? it's been your username forever hasn't it
10:19:28 <CakeProphet> no
10:19:31 <fizzie> Patashu: "opposite two letters before all strings of length 2" does not directly work, because you can't have "ab" before "ba".
10:19:31 <CakeProphet> no such thing.
10:19:45 <monqy> 03:20:43 [freenode] -!- CakeProphet [~adam@h222.0.18.98.dynamic.ip.windstream.net]
10:19:48 <monqy> 03:20:43 [freenode] -!- ircname : adam
10:19:53 <monqy> ~adam@...
10:19:53 <CakeProphet> lies, fabricated documents.
10:19:57 <monqy> real name: adam
10:20:29 <CakeProphet> there is no such thing as username it is a Freenode contrivance
10:20:45 <CakeProphet> Freenode hacked all RFCs to show it in the IRC protocol
10:20:52 <CakeProphet> again, a figment of nothingness.
10:21:16 -!- CakeProp1et has joined.
10:21:21 <monqy> hi
10:21:22 -!- CakeProp1et has quit (Client Quit).
10:21:32 <CakeProphet> bah
10:21:34 -!- CakeProphet has quit (Client Quit).
10:21:51 -!- CakeProphet has joined.
10:23:08 <CakeProphet> I bet a function called contrive in Haskell would do something neat.
10:29:23 <Patashu> fizzie, opposite two letters means a/c before b, a/b before c, b/c before a
10:29:24 <Patashu> it works
10:29:24 <Patashu> so
10:29:31 <fizzie> Yes, I realizezed it later.
10:29:51 <fizzie> The "ab before c" thing was just confusingly put; it didn't immediately read as "a or b before c".
10:31:24 -!- copumpkin has quit (Ping timeout: 258 seconds).
10:31:49 -!- copumpkin has joined.
10:33:27 <fizzie> The corresponding OEIS A001333 is commented as being "Number of n-words from the alphabet A={0,1,2} which two neighbors differ by at most 1"; that's pretty much the same thing, except it avoids the 'ac' and 'ca' substrings as opposed to 'aa' and 'bb'.
10:33:55 <Patashu> hm!
10:33:58 <Patashu> interesting
10:34:32 -!- DH____ has joined.
10:43:19 -!- DH____ has quit (Read error: Connection reset by peer).
10:43:23 -!- DHeadshot has joined.
11:16:45 <Patashu> http://www.chessvariants.org/other.dir/captain-spalding.html chess where you can find an elephant in your pajamas
11:28:06 -!- oerjan has joined.
11:29:33 <CakeProphet> Patashu: wow that looks fun I'll have to play that with some friends.
11:29:47 <Patashu> play this one too http://www.chessvariants.org/other.dir/nemoroth.html
11:34:46 <oerjan> > let f = 1:3:8:map(sum.take 3)(tails f) in f
11:34:48 <lambdabot> [1,3,8,12,23,43,78,144,265,487,896,1648,3031,5575,10254,18860,34689,63803,1...
11:35:02 <Patashu> > let f = 1:3:7:map(sum.take 3)(tails f) in f
11:35:04 <lambdabot> [1,3,7,11,21,39,71,131,241,443,815,1499,2757,5071,9327,17155,31553,58035,10...
11:39:49 <oerjan> <CakeProphet> !addinterp monqy haskell import Data.Char;import Control.Monad putStrLn =<< fmap toLower getContents
11:39:53 <oerjan> i sense a missing ;
11:40:20 <oerjan> if EgoBot's version of ghci even supports import
11:40:54 <CakeProphet> ...oh
11:41:00 <CakeProphet> so I just came up with an awesome chess variant.
11:41:05 <CakeProphet> which I will not write down.
11:41:09 <Patashu> why not
11:41:12 <CakeProphet> er
11:41:13 <CakeProphet> will now
11:41:15 <CakeProphet> write down
11:41:20 <Patashu> that's a better idea
11:41:21 <Patashu> hmmm
11:41:29 <Patashu> esolangs should have an esoteric chess variants/esoteric games variants page
11:41:31 <oerjan> Patashu: freudian sex day
11:41:34 <oerjan> *slip
11:41:59 <CakeProphet> Patashu: it will have a two piece-generators kind of like captain spalding
11:42:16 <CakeProphet> and any pieces adjacent to the piece-generator can be swapped with pieces that are adjacent to the other generator.
11:43:18 <Patashu> example of esoteric chess http://www.chessvariants.org/diffmove.dir/oomost-chess.html
11:43:28 <CakeProphet> also, there are cannons that shoot projectiles. it's a two turn process. The projectile is spawned adjacent to the cannon, and then at the END of your next turn it fires "forward" and captures any pieces in its path
11:43:45 <Patashu> shooting pieces are quite powerful
11:43:47 <Patashu> make sure they're balanced
11:43:56 <CakeProphet> unless it hits a barrier (knight) which redirects the projectile path, based on the direction that the knight's nose is pointing.
11:44:00 <CakeProphet> the two turn thing makes it more balanced.
11:44:19 <CakeProphet> a knight can spend a turn to reorient its nose.
11:44:38 <CakeProphet> also the projectile might stop once it captures a single piece
11:44:44 <CakeProphet> instead of like... clearing everything in its path.
11:44:48 <oerjan> <monqy> _not if there are multiple words_
11:44:54 -!- ais523 has joined.
11:44:54 <oerjan> actually mine does
11:44:59 <monqy> huh
11:45:03 <oerjan> (i set an option for it)
11:45:09 <monqy> ah
11:45:37 <CakeProphet> but it seems to me that the strategy would basically involve tricking your opponents with barriers and cannons, or using their own pieces against them.
11:45:39 <oerjan> emphasis_multiword
11:45:58 <Patashu> http://www.chessvariants.org/multiplayer.dir/anynumber.html FFA chess
11:46:09 <CakeProphet> and because the projectile is at the end of your next turn and happens as an extra action in your turn, it means you can use the teleporting effect to suddenly change its path..
11:46:20 <monqy> set; _trying it out now_
11:46:22 <monqy> seems to work
11:47:03 <CakeProphet> so then a cannon is basically like a rook that doesn't move to capture and requires two turns to capture... minus the whole redirecting bit.
11:47:51 <CakeProphet> also the redirecting effect would be piece neutral meaning you can use opponent barriers (maybe I should call them arrows?) to redirect.
11:48:00 <fizzie> oerjan: What does it do if someone emphasises multiple words _like_this_?
11:48:08 <oerjan> fizzie: nothing, alas
11:48:18 <oerjan> _like_this_ testing
11:48:21 <Jafet> I think you're describing befunge, not chess.
11:48:22 <oerjan> not that either
11:48:30 <Jafet> (Multiplayer befunge!)
11:48:38 <monqy> _who_emphasises_like_this_seriously_
11:48:51 <CakeProphet> Jafet: kind of I guess.
11:48:57 <CakeProphet> I could add a trampoline just for fun. :P
11:49:20 <oerjan> lemmings chess
11:49:24 <monqy> a trampoline as in that sort or something else
11:49:34 <CakeProphet> but anyways cannons are rooks I guess so there's only two. missiles are bishops because they look like missiles.
11:49:55 <CakeProphet> a trampoline would be like a befunge trampoline in that the projectile won't capture whatever is after the trampoline, and doesn't capture the trampoline either.
11:50:00 <CakeProphet> they're little safety nets.
11:50:15 <oerjan> _what about this_?
11:50:19 <oerjan> that works
11:50:22 <CakeProphet> not for me.
11:50:34 <monqy> works for me
11:50:39 <monqy> set emphasis_multiword
11:50:48 <monqy> (to on)
11:50:51 <fizzie> I think for underlining _doing_it_like_this_ still makes a modicum of sense, but *doing*this*certainly*doesn't*.
11:50:57 <CakeProphet> also a missile can be captured in the turn it's spawned, which makes it not fire next turn obviously.
11:51:35 <CakeProphet> and once it fires it leaves the board... because it's just a projectile thing.
11:52:02 <oerjan> _this then?_
11:52:07 <oerjan> doesn't
11:52:20 <CakeProphet> _test test_
11:52:22 <CakeProphet> there we go
11:52:26 <CakeProphet> *bahahahaha
11:52:27 <CakeProphet> *bahahahaha*
11:52:30 <CakeProphet> *bahahahah haa*
11:52:46 <oerjan> oh no, we've made a monster!
11:52:46 <CakeProphet> okay so the cannon thing is pretty central at this point, I need some other ideas.
11:53:58 <CakeProphet> man I wish some other piece had directionality. everything but the knight has top-down radial symmetry.
11:54:24 <fizzie> http://sprunge.us/bhFN?c -- irssi highlighter isn't the prettiest ever. (I remember looking at it earlier too.)
11:54:50 <monqy> :(
11:55:04 <monqy> this sads me
11:55:18 <fizzie> Also I see some tab issues there; shouldn't have displayeded it with unholy four-char tabs.
11:55:34 <monqy> the code itself, not irssi's not being the prettiest ever
11:56:09 <monqy> i like 2-space indentation because i'm a weirdo
11:56:28 <Jafet> You are referring to Stanton pieces? The bishop has radial asymmetry.
11:56:45 <CakeProphet> erm...
11:56:52 <Jafet> The other pieces, well... fix them with a sharpie
11:57:00 <CakeProphet> I don't know?
11:57:19 <Jafet> http://en.wikipedia.org/wiki/Staunton_chess_set
11:57:20 <CakeProphet> most games i've played the bishop is radial.
11:57:28 <Jafet> Chess is supposed to be independent of the piece shapes
11:57:38 <CakeProphet> yeah no notches in my chess sets.
11:57:52 -!- ais523 has quit (Remote host closed the connection).
11:59:09 -!- ais523 has joined.
11:59:40 <CakeProphet> okay so if the projectile passes through the friendly king (an exception to the projectiles-kill-anything-except-arrows rule) then the trampoline (pawn) effect is reversed so that the projectile ONLY captures after a trampoline
12:00:00 <CakeProphet> hmmm, well no
12:00:09 <CakeProphet> it will capture the trampoline. because otherwise they are kind of hard to kill.
12:00:18 <CakeProphet> ????
12:01:06 <CakeProphet> I dunno if this is a good game yet, lol
12:02:45 <CakeProphet> the queen being a spawner and the queen/king being able to swap pieces that are adjacent to them makes mobility more interesting, as most of the pieces besides the queen are going to be rather slow moving.
12:02:56 <Patashu> http://www.chessvariants.org/d.betza/chessvar/missmark.html lol
12:02:59 <CakeProphet> but I think the two-turn projectile part is an issue because it sounds easy to avoid.
12:03:31 <CakeProphet> especially when you set up your king to reverse the trampoline effect. extra prep time = more obviousness = less fun
12:05:23 <CakeProphet> and it would be trivial for the opponent to just move the trampoline out of the way in the one turn they have to react... unless they have to do something else, but there are fewer situations like that than in chess.
12:05:32 <oerjan> <CakeProphet> EGADS MY REAL NAME HAS BEEN EXPOSED.
12:05:49 <oerjan> i suggest you change your username to your last name so it doesn't happen again.
12:05:55 <CakeProphet> heh
12:06:01 * oerjan whistles innocently
12:06:05 <CakeProphet> well the pawns could just be like... pawns.
12:06:11 <CakeProphet> instead of trampolines
12:06:24 <CakeProphet> so they're just one-time barriers.
12:06:31 <CakeProphet> no, bad idea.
12:06:53 <CakeProphet> opening streategy: surround king in layers of pawns
12:08:42 <CakeProphet> also I think I'll free up the bishop as missile by having pawns be missiles. if a pawn is adjacent to a missile then it gets fired off.
12:09:15 <CakeProphet> obviously now bishops are extra-dimensional portals
12:09:41 <ais523> CakeProphet: this whole concept is rather ridiculously zzoish
12:09:45 <ais523> are you sure you want to go down that route?
12:09:56 <CakeProphet> ....how so?
12:10:28 <oerjan> i understand zzo is a _regular_ contributor to chessvariants.org
12:10:34 <CakeProphet> oh.
12:10:35 <CakeProphet> oh well.
12:10:40 <CakeProphet> chess variants are cool.
12:11:05 <ais523> it's more the whole making a massively complicated variant of something existing thing
12:11:38 <oerjan> extended tic-tac-toe
12:11:43 <CakeProphet> so yeah the bishop is a portal, a projectile goes into its notch and comes out the other bishops notch. teleporting redirecting clusterfuck ensues.
12:12:09 <CakeProphet> I guess some pieces are immortal or something? I don't know.
12:12:30 <ais523> oerjan: that reminded me of the generalised Sudoku I came up with when trying to work out an infinite Sudoku so I could figure out if it was TC or not
12:12:56 <oerjan> one of the pawns is immortal, however this is marked _under_ it so the opponent can only find out which by capturing it.
12:13:07 <oerjan> *trying to capture
12:13:08 <CakeProphet> haha
12:13:18 <CakeProphet> THE IMMORTAL TRAMPOLINE.
12:13:33 <CakeProphet> I dunno if I like the trampoline.
12:13:42 <CakeProphet> maybe pawns should do something else. Something useful and numerous.
12:14:11 <oerjan> ais523: "generalised sudoku is NP-complete"
12:14:22 <oerjan> although that's not infinite
12:14:30 <ais523> oerjan: hmm
12:14:33 <CakeProphet> ...imagine if pawns were prisms, and caused projectiles to split cardinally in three directions.
12:14:45 <ais523> in other puzzles I've seen, normally pspace-complete on finite puzzles generalized to TC on infinite ones
12:14:59 <ais523> although I don't think that's well-defined enough for it to be possible to make a theorem out of it
12:15:22 <CakeProphet> maybe the friendly queen could be a prism. that would be kind of ridiculous.
12:16:00 <oerjan> CakeProphet: that sounds like you get some dangerous exponential blowup
12:16:11 <CakeProphet> well with the pawns yeah.
12:16:32 <CakeProphet> -100 turns of careful setup- -SUDDENLY EVERYTHING DIES-
12:17:21 <oerjan> that's a bit similar to uranium, actually
12:17:26 <CakeProphet> perhaps the bishops will be the teleporters as well as portal-things. they will just be portals.
12:18:02 <CakeProphet> and they can still be captured by shooting them on any of their notchless sides.
12:18:10 <CakeProphet> well, no...
12:18:25 <CakeProphet> well, maybe? you wouldn't have a portal at that point because one of the links would be broken.
12:18:55 <CakeProphet> it would seem that losing any of your major pieces would put you at a huge disadvantage.
12:19:40 -!- sllide has joined.
12:20:51 <oerjan> how shockingly unlike ordinary chess
12:21:05 <CakeProphet> but I think it's more of a disadvantage here
12:21:09 <CakeProphet> because all of your pieces do ridiculous things.
12:21:28 <CakeProphet> like teleport other pieces around..
12:25:57 <CakeProphet> obviously the solution is to introduce even more complicated rules
12:26:04 <Patashu> obviously
12:26:07 <CakeProphet> so now that when a teleporter or portal becomes unlinked it behaves differently.
12:26:18 <CakeProphet> in a way I have not decided.
12:27:59 <CakeProphet> bahahaha, when you kill a teleporter/portal the other one explodes and takes all adjacent pieces with it.
12:28:20 <CakeProphet> problem solved.
12:28:56 <CakeProphet> in any case I suspect capturing pieces will be incredibly difficult and will rely entirely on convoluted piece setups.
12:29:16 <Patashu> I'm kind of reminded of some roles I designed for the game of mafia, which only produce interesting results with lots of other 'power roles', but such a game requires huge amounts of players to not be ridiculous full of power roles
12:29:25 <Patashu> From all the nonsense I am hearing about here
12:29:55 <CakeProphet> well I can have two different kinds of pawns I realized by placing sharpie marks on some.
12:30:32 <CakeProphet> so I was thinking I could have four arrows which are marked pawns, and then that frees up knights to be portals, and then bishops are teleporters.
12:30:45 <CakeProphet> currently the two rooks are cannons but one could be flipped over to do something else.
12:31:39 <Patashu> have you considered making a chu chu rocket mod instead of a chess mod?
12:31:49 <CakeProphet> wat
12:31:56 <Patashu> it's a dreamcast game
12:32:14 <CakeProphet> really I don't see an issue with everything being over the top as long as it's fun.
12:32:21 <Patashu> hah, yeah
12:33:13 <CakeProphet> I haven't really worked out movement yet. Just the projectile dynamics.
12:33:42 <CakeProphet> cannons will be slow I think. one or two space movers. teleporters should be quick and be able to jump over things.
12:34:37 <CakeProphet> but perhaps with weird movement restrictions.
12:36:11 <CakeProphet> portals could be replaced with something else but they sound like great fun.
12:36:31 <CakeProphet> and teleporters and portals may be merged into one piece so that "walking into a portal" is the teleport effect.
12:37:19 <CakeProphet> also I just realized with four arrows one could make an infinite projectile loop...
12:38:19 <CakeProphet> also with one arrow and two portals you can create the same loop but without the square pattern.
12:38:40 <CakeProphet> I guess these could just set up death walls until the chain is broken... muahahahaha
12:40:21 <CakeProphet> and these death walls could be redirected by arrows or portals (as long as they're facing the right direction otherwise they would be captured)
12:40:31 <CakeProphet> and thus fed into possibly another infinite loop.
12:41:07 <CakeProphet> so basically an arrow in one of these loops would just have to turn a direction to capture something....
12:41:38 <CakeProphet> thus breaking the loop.
12:42:15 <CakeProphet> wow that's awesome.
12:42:22 <CakeProphet> this is the best rule abuse ever.
12:43:53 <CakeProphet> most pieces at this point don't even get captured by projectiles.
12:44:05 <CakeProphet> thus making it difficult to capture things.
12:45:23 -!- monqy has quit (Quit: hello).
13:14:50 -!- CakeProphet has quit (Ping timeout: 260 seconds).
13:40:12 -!- variable has quit (Ping timeout: 255 seconds).
13:40:16 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 .).
14:01:09 -!- Guest79464 has changed nick to Gregor.
14:01:38 -!- Gregor has changed nick to Guest16962.
14:10:46 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
14:36:44 -!- copumpkin has joined.
14:52:31 <ais523> hmm, is writing "more *.txt | cat" a useless use of cat?
14:52:48 <ais523> it's the simplest way I know to tell more to act like it isn't connected to a terminal
14:53:46 <oerjan> sounds like the answer is "no"
14:56:58 -!- azaq23 has joined.
14:57:33 -!- pumpkin has joined.
14:58:03 -!- copumpkin has quit (Ping timeout: 252 seconds).
14:58:22 -!- pumpkin has changed nick to copumpkin.
14:59:20 -!- azaq23 has quit (Client Quit).
15:01:02 -!- Taneb has joined.
15:01:13 <Taneb> Hello!
15:01:33 -!- oerjan has quit (Quit: Goodbye!).
15:06:29 <Sgeo> How are you?
15:06:50 <Taneb> Alright
15:09:24 <Deewiant> Alleft
15:12:39 <Taneb> The world of esoteric programming seems quiet
15:12:50 <Taneb> I blame the awful weather in Hexham
15:12:52 <ais523> Sgeo: a bit ill, but recovering
15:13:15 <Sgeo> o.O, glad you're recovering, feel even better soon
15:15:36 -!- hagb4rd has joined.
15:15:44 <hagb4rd> waidmannsheil
15:16:04 <hagb4rd> sry wrong chan
15:16:11 <Taneb> Why not stay?
15:17:28 <hagb4rd> me?
15:17:32 <Taneb> Yes
15:18:11 <hagb4rd> oh, i'm gonna stay for a while, sure
15:18:18 <hagb4rd> how are things goin?
15:18:30 <Taneb> Just out of curiousity, which channel did you mean to post that in?
15:18:36 <Taneb> "waidmannsheil", that is
15:18:54 <hagb4rd> german-elite.net#gulli
15:19:00 <Taneb> Okay
15:19:33 <hagb4rd> where is elliott?
15:19:45 <Taneb> Relatively close to where I am
15:21:05 <hagb4rd> relativly close yess :)
15:21:16 <Taneb> That sounds disturbing...
15:21:41 <hagb4rd> well it could mean anything at all
15:22:02 <hagb4rd> but that's one of worlds mysteries i guess
15:22:33 -!- FireFly has joined.
15:22:40 <Taneb> What do you think about http://esoteric.voxelperfect.net/wiki/User:Taneb/Salesman ?
15:24:22 <fizzie> ais523: Assuming you're using that to just get per-file headers in there (or does 'more' do something more (no pun intended) when not in terminal), "head -n -0 *.txt" is an alternative (with different-looking file headers).
15:24:50 <hagb4rd> well, does it work? sounds like a pretty fast solution, not goin into details
15:25:02 <hagb4rd> is that kind of a*?
15:25:04 <fizzie> s/nal/nal?/
15:32:05 <Deewiant> Alas, that head invocation is not as portable as more.
15:32:40 <Deewiant> The Solaris man page for head(1) suggests head -9999.
15:34:51 -!- variable has joined.
15:37:40 -!- calamari has joined.
15:42:43 <Guest16962> ARGH
15:42:56 -!- Guest16962 has changed nick to Gregor.
15:43:08 <Sgeo> Oh, so that wasn't deliberate.
15:43:40 <Gregor> My bouncer doesn't identify for me.
15:45:10 <Sgeo> Ah
15:53:05 -!- calamari has quit (Quit: Leaving).
15:55:26 <Taneb> flip (flip id (+1)) 0
15:56:03 <Deewiant> No instance for (Show (((a0 -> a0) -> b0 -> c0) -> c0))
15:56:24 <Taneb> > flip (flip id (+1)) 0 (const id)
15:56:26 <lambdabot> 0
15:56:39 <Taneb> flip (flip id (+1)) 0 id
15:56:53 <Deewiant> 1
15:57:07 <Taneb> I bet there is a shorter way of writing that
15:57:18 <Deewiant> Yes: 1
15:57:29 <Taneb> \x->x(+1)0
15:57:51 <Deewiant> ?pl \x->x(+1)0
15:57:51 <lambdabot> flip ($ (1 +)) 0
15:59:26 <Taneb> ?pl \x->\y->x y y
15:59:26 <lambdabot> join
16:01:37 <Taneb> ?pl \x -> \y -> \z -> x z (y z)
16:01:37 <lambdabot> ap
16:03:54 <Taneb> > flip ($ (1+)) 0 (ap (.) (join (.)))
16:03:56 <lambdabot> 3
16:04:19 <Taneb> ?pl ap (.) $ join (.)
16:04:19 <lambdabot> ap (.) (join (.))
16:04:34 <Deewiant> ?. pl unpl ap (.) $ join (.)
16:04:34 <lambdabot> (join (.) >>=) . (return .) =<< (.)
16:04:56 <Taneb> brb
16:06:57 <Taneb> Right, I've been delivered a box
16:07:02 <Taneb> I can't get into the box
16:07:09 <Taneb> It may contain my laptop
16:07:29 <Taneb> But, according to the latest theories in Quantum Mechanics, I can't tell until I open it
16:07:43 <Taneb> Found some scissors
16:10:12 <Taneb> It's my laptop!
16:10:27 <Taneb> Sans battery
16:13:42 <Taneb> They've uninstalled ubuntu
16:14:32 <Taneb> They've completely wiped it
16:14:41 <Taneb> I thought that they would
16:15:53 <hagb4rd> so now you need some food for your cat, right?
16:15:58 <hagb4rd> or is it dead?
16:16:15 <Taneb> It turned out to be a dog
16:16:18 <hagb4rd> lol
16:19:07 <Taneb> First step: install decent browse
16:19:08 <Taneb> r
16:19:12 <Taneb> BUT WHICH ONE?
16:19:28 <Taneb> Bah, I'll get Firefox, Chrome, AND Opera
16:28:56 <Taneb> I am browsered up
16:28:59 <Taneb> Now to get GHC
16:29:05 <coppro> Taneb: don't forget IE
16:29:15 <fizzie> Try to whip up some sort of a thing that uses all the browsers simultaneously.
16:29:20 <Taneb> Installed by default
16:29:21 <Sgeo> Why would you leave the HD in?
16:29:53 <Sgeo> Or was it a software issue
16:30:23 <Taneb> The HD was where the problem was
16:30:48 <Sgeo> Oh
16:31:00 -!- elliott has joined.
16:31:43 <elliott> sup
16:32:05 <Taneb> Hey!
16:32:16 <Taneb> Weather's miserable, isn't it?
16:32:46 <elliott> no i live in latvia and as such have no idea what you are talking about
16:33:00 <elliott> facts
16:33:39 <fizzie> Hexham, Latvia.
16:34:22 -!- Gregor has changed nick to Guest16962.
16:34:50 <elliott> yes
16:43:45 <Taneb> Finally installing Haskell Platform
16:43:53 <Taneb> Next: Minecraft and Dwarf Fortress
16:44:42 <elliott> how many computers do you use exactly
16:46:34 <Taneb> 2-5, depending how you count it
16:46:54 <Taneb> Including the ones at school, anything up to about 30
16:48:20 <Deewiant> ?hoogle Applicative f => f (a -> b) -> (b -> c) -> f (a -> c)
16:48:20 <lambdabot> Data.Generics.Schemes everywhereBut :: GenericQ Bool -> GenericT -> GenericT
16:48:30 <elliott> Deewiant: Oh god what are you doing.
16:48:57 <Deewiant> Trying to save a pair of parentheses in f <*> (g <$> x)
16:48:59 -!- ive has joined.
16:49:38 <elliott> Deewiant: ap f $ g <$> x
16:49:52 <elliott> Or even ap f $ fmap g x
16:50:12 <Taneb> Installing Minecraft and Dwarf Fortress
16:50:13 <Deewiant> But ap isn't for Applicatives :-/
16:50:30 <Deewiant> I've managed to avoid importing Control.Monad
16:50:47 <elliott> Deewiant: ap = (<*>)
16:50:52 <Deewiant> ?ty ap
16:50:53 <lambdabot> forall (m :: * -> *) a b. (Monad m) => m (a -> b) -> m a -> m b
16:50:59 <elliott> Deewiant: I'm telling you to define it locally :P
16:51:05 <elliott> (At module scope)
16:51:12 <Deewiant> Meh
16:51:20 <elliott> :t (<$>)
16:51:21 <lambdabot> forall a b (f :: * -> *). (Functor f) => (a -> b) -> f a -> f b
16:51:23 <elliott> I swear it used to be Applicative
16:51:28 <elliott> Deewiant: Uh wait
16:51:33 <elliott> Deewiant: f <*> fmap g x
16:51:34 <elliott> Duh
16:52:23 <Deewiant> That'd need to be fmap g $ x and I can't do that because of cannot mix `$' [infixr 0] and `<?>' [infix 0] in the same infix expression
16:52:38 <elliott> 22:44:34: <HackEgo> 2010-12-17.txt:19:31:42: <Deewiant> elliott: No, but my toaster is.
16:52:38 <elliott> Me too
16:52:53 <elliott> Deewiant: Can I see your expression, I'd like to tell you how much I dislike you for writing it
16:53:05 <elliott> Also how much it needs parentheses
16:53:24 <elliott> Also: I wonder if trifecta's <?> has better precedence :-)
16:53:48 <Deewiant> punctuator = here PPPunctuator <*> (fromJust.punctuatorFromString <$>
16:53:49 <Deewiant> (choice $ map string
16:53:49 <Deewiant> [ "->", "++", "--", "<<=", ">>=", "<=", ">=", "==", "!="
16:53:49 <Deewiant> , "&&", "||", "...", "*=", "/=", "%=", "+=", "-=", "<<"
16:53:49 <Deewiant> , ">>", "&=", "^=", "|=", "##", "<:", ":>", "<%", "%>"
16:53:51 <Deewiant> , "%:%:", "%:"]
16:53:53 <Deewiant> ++ [(:[]) <$> satisfy ((`IS.member` punctuatorChars).ord)]))
16:53:56 <Deewiant> <?> "punctuator"
16:54:16 <elliott> "PPPunctuator"?
16:54:17 <Deewiant> Hmm, trifecta
16:54:23 <Deewiant> Hadn't noticed that one
16:54:33 <elliott> It's the hot new thing
16:54:40 <elliott> Gives clang-style diagnostics
16:54:44 <elliott> ANSI and all
16:54:49 <elliott> data Parser e a = Parser
16:54:49 <elliott> { unparser :: forall r.
16:54:49 <elliott> (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> -- uncommitted ok
16:54:49 <elliott> ( ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> -- uncommitted err
16:54:49 <elliott> (a -> ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> -- committed ok
16:54:50 <elliott> ( ErrState e -> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r) -> -- committed err
16:54:51 <elliott> ErrLog e -> Bool -> Delta -> ByteString -> It Rope r
16:54:53 <elliott> }
16:54:55 <elliott> Nice
16:55:28 <elliott> Deewiant: BTW bugreport "fromJust.punctuatorFromString"
16:55:33 <elliott> Needs spaces
16:55:37 <Deewiant> No it doesn't
16:55:42 <elliott> Additionally ).ord
16:55:50 <elliott> Deewiant: Yeah it does, you couldn't replace fromJust with a constructor there
16:55:52 <Deewiant> . totally doesn't need spaces
16:55:54 <elliott> Which is terrible
16:56:01 <Deewiant> That's Haskell's problem, not mine
16:56:03 <elliott> I think TDNR would also make that invalid but don't quote me on it
16:56:07 <Deewiant> TDNR?
16:56:10 <Deewiant> Oh
16:56:11 <elliott> Type-directed name resolution
16:56:11 <elliott> Deewiant: You're writing Haskell
16:56:24 <elliott> Are you designing your code to be difficult to change? :-P
16:56:40 <elliott> Anyway, my solution is to use the parens and just put the multi-line shit in its own "where"-define
16:58:49 <Deewiant> Then I'll just use the parens and not put the multi-line shit in its own "where"-define
16:58:58 <elliott> Gross
16:59:01 <Taneb> Minecraft and Dwarf Fortess installed
16:59:03 <Deewiant> Does trifecta have lookAhead
16:59:11 <Taneb> Next: some sort of IRC client
16:59:21 <elliott> Deewiant: What does that do again
16:59:23 <Taneb> Any reccomendations for Windows IRC clients?
16:59:34 <Deewiant> elliott: Parse without changing the position, essentially
16:59:37 <elliott> Taneb: Silverex works alright
16:59:40 <Deewiant> I justt need one-character lookahead
16:59:42 <elliott> Deewiant: You mean try?
16:59:45 <Deewiant> No
16:59:47 <elliott> Hmm
16:59:50 <elliott> I see
16:59:53 <Deewiant> I need it to not change the position even when it succeeds
16:59:57 <elliott> Can't you simulate that with try always
17:00:01 <Deewiant> How
17:00:12 <elliott> (try a >> deriv e a) <|> e
17:00:21 <elliott> Where (deriv e a) is e with the a at the front stripped off :P
17:00:37 <elliott> Anyway, I dunno if it does, but it has documentation :P
17:00:44 <elliott> I would assume so
17:00:46 <Deewiant> I need to parse (x *> lookAhead newline)
17:00:52 <Deewiant> Er, <*
17:01:04 <Deewiant> I'm looking for it but can't find it :-P
17:01:10 <elliott> ?hoogle lookAhead
17:01:10 <lambdabot> Text.Parsec.Combinator lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
17:01:10 <lambdabot> Text.ParserCombinators.Parsec.Combinator lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
17:01:10 <lambdabot> System.IO hLookAhead :: Handle -> IO Char
17:01:16 * elliott tries hayoo
17:01:29 <Deewiant> Hayoo found it
17:01:33 <Deewiant> http://hackage.haskell.org/packages/archive/trifecta/latest/doc/html/Text-Trifecta-Parser-Class.html#v:lookAhead
17:01:53 <Deewiant> No default definition suggests that no, it can't be simulated :-P
17:02:03 <elliott> It can be simulated for any given full parser
17:02:09 <elliott> You need to transform what comes next, is all
17:02:19 <Deewiant> Yeah I don't want to rewrite my whole parser
17:02:21 <elliott> That is, (lookAhead p >> q) can be simulated
17:02:31 <elliott> instance MonadParser m => MonadParser (Yoneda m) where
17:02:38 <elliott> Thank god
17:02:46 <Deewiant> Yoneda is a lot of things
17:02:47 <elliott> I'm sure he actually uses that :P
17:03:02 <elliott> infix 0 <?>
17:03:08 <Deewiant> D'oh
17:03:19 <elliott> Yeah, but hot new thing, how can you not?
17:03:26 <elliott> I like how
17:03:27 <elliott> -- | Lexeme parser |semi| parses the character \';\' and skips any
17:03:27 <elliott> -- trailing white space. Returns the character \';\'.
17:03:29 <elliott> is a primitive
17:03:54 <Deewiant> Where's thattt
17:03:56 <Deewiant> ttttttttttttttttttttttttttt
17:04:17 <elliott> Deewiant: http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/Text-Trifecta-Parser-Class.html
17:04:18 <Deewiant> Today is a bad day for my t button
17:04:35 <elliott> Ttttoday
17:04:49 <Deewiant> Yeah, that doesn't seem like something that needs to be in the class :-P
17:05:09 <elliott> Deewiant: It's probably an optimisation
17:05:25 <Deewiant> For semicolons?
17:05:27 <Deewiant> Whyyy
17:05:32 <elliott> Language parsing
17:05:43 <elliott> I'd bet money on it being an optimisation
17:06:16 <elliott> Deewiant: Trifecta also gets you layout parsing in case you're parsing Haskell :-P
17:06:28 <elliott> You MIGHT be!
17:06:48 <Deewiant> Does it have manyTill1 :: Alternative f => f a -> f end -> f ([a], end)
17:07:13 <elliott> No; can't you write that yourself
17:07:28 <Deewiant> Yes, and I have because Parsec doesn't have it
17:07:45 <Deewiant> Just seems like something that would be generically useful :-P
17:07:46 <elliott> manyTill :: (Alternative m, MonadPlus m) => m a -> m end -> m [a]
17:07:46 <elliott> manyTill p end = go where go = ([] <$ end) <|> ((:) <$> p <*> go)
17:07:46 <elliott> That's one readable definition
17:07:51 <Deewiant> Ehm
17:07:52 <Deewiant> p `manyTill1` end = fix $ ((,) [] <$> end <|>) . liftA2 (first . (:)) p
17:08:01 <elliott> How did you make it even more readable
17:08:04 <elliott> I thought it impossible
17:08:10 <Deewiant> I've got skillz
17:08:23 <elliott> Seriously though, I hate you and your code
17:08:29 <Deewiant> That's actually an easy derivation from that manyTill
17:08:37 <elliott> Well that excuses it
17:08:38 <Deewiant> Parsec has an ugly monadic definition
17:08:47 <elliott> It's so ugly I might even understand it first time
17:10:09 <elliott> 02:31:29: * Sgeo__ decides no one here wants to hear about what happened today.
17:10:09 <elliott> 02:31:35: <Sgeo__> And even if someone did: It's private.
17:10:15 <elliott> Sgeo: Unfortunately you are now obligated to tell us all
17:10:18 <elliott> I will weep in the corner
17:11:06 <Taneb> Now I have four browsers, Minecraft, Dwarf Fortress, Haskell, and an IRC Client, it is time to install Ubuntu
17:11:23 <Sgeo> elliott, there may have been some hints further in the log
17:11:25 <Sgeo> <,<
17:11:44 <ais523> Taneb: ?
17:12:19 <Taneb> Got my laptop back with a wiped hard drive
17:12:28 <Taneb> It had BSODed badly
17:13:01 <Taneb> I tend to switch between Ubuntu and Windows, and Windows is preinstalled
17:13:40 <elliott> ais523: helo
17:13:54 <elliott> 03:35:18: <qnix> any one extremely good with md5 collision and brainfuck language pm me ? :)
17:14:02 <elliott> qnix: are you trying to program in shafuck
17:14:02 <elliott> execpt
17:14:04 <elliott> wtih md
17:14:07 <elliott> instead of sha i guess
17:14:34 <ais523> elliott: 250 Hello elliott
17:14:44 <elliott> ais523: help
17:15:24 <ais523> err, I don't make a very good SMTP server
17:15:42 <elliott> help
17:15:50 <Taneb> hlep
17:15:53 <ais523> it took me that long to look up that 250 was the correct number to use for a HELO response
17:16:11 <elliott> Taneb: what is happening outside, did gangs break the weather or something
17:16:16 <elliott> i dont think the sky is normally that colour
17:16:46 <elliott> Deewiant: Also you should use IntSet rather than IS for that qualified import
17:16:51 <elliott> It is the wisdom of zomgm- elliott
17:16:58 <Deewiant> So verbose
17:17:05 <ais523> !help
17:17:05 <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>.
17:17:13 <ais523> `help
17:17:14 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
17:17:15 <elliott> Deewiant: I would like to ban you from using Haskell
17:17:18 <elliott> At least I can read CCBI
17:17:18 <Taneb> I see nothing wrong with a yellowy grey sky
17:17:24 <elliott> it's yellowy?
17:17:25 <fizzie> ^help
17:17:25 <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
17:17:36 <Taneb> More smurgy
17:17:56 <elliott> is smurgy a word
17:18:11 <Deewiant> elliott: Reading IS.member isn't so hard :-P
17:18:29 <elliott> Deewiant: The rest of it is a bigger problem
17:18:43 <Taneb> It's sort of like lurgy and smoggy
17:20:45 <Taneb> Did anyone look at Salesman?
17:20:59 <Taneb> Also, bye
17:21:21 -!- Taneb has changed nick to Taneb|Hoverpack.
17:22:23 <Deewiant> elliott: Does trifecta treat '\t' as advancing 1 column or more
17:22:38 <elliott> Deewiant: Wait, you actually are doing layout?
17:22:54 <elliott> Also you realise I'm just reading the source to answer these
17:22:55 <Deewiant> No, I just hate error messages that depend on a tab width
17:23:00 <elliott> Oh
17:23:07 <elliott> ais523:
17:23:11 <elliott> Deewiant: Enjoy your trolling
17:23:21 <ais523> elliott: gah, a bot in another channel's gone mad and is doing nick: on everyone when they arrive
17:23:26 <Deewiant> I'm not trolling, dammit
17:23:32 <elliott> Deewiant: No, enjoy ais523's trolling of you
17:23:44 <elliott> ais523: Deewiant just said something that implied that there exists a "tab width" that doesn't necessarily have to have the value eight
17:23:49 <Deewiant> I wouldn't call what he's doing trolling, either
17:23:56 <elliott> It's what he's about to do
17:24:01 <Deewiant> I know what he's about to do
17:24:09 <Deewiant> Or what you want him to do
17:24:13 <Deewiant> And I wouldn't call that trolling
17:24:37 <elliott> http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/src/Text-Trifecta-Parser-Prim.html I think this answers your question
17:24:44 <ais523> elliott: it's an esolang, I wouldn't expect them to use standard meanings for tab just like I wouldn't expect them to use standard meanings for space
17:24:48 <ais523> either that, or it isn't an esolang
17:24:55 <ais523> in which case it's probably just wrong
17:24:59 <elliott> ais523: I don't know that it's an esolang
17:25:07 <ais523> well, this is #esoteric
17:25:12 <elliott> Yes, so it probably isn't
17:25:13 <ais523> I assume anything I haven't heard of is an esolang until proven otherwise
17:25:13 <Deewiant> It's just error messages generically
17:25:30 <elliott> Deewiant: Pretty sure it doesn't handle tabs specially
17:25:35 <elliott> There's '\n' casing but no \t
17:25:46 <elliott> Hmm
17:25:48 <elliott> data Delta Source
17:25:48 <elliott> Constructors
17:25:48 <elliott> Columns !Int64 !Int64
17:25:48 <elliott> Tab !Int64 !Int64 !Int64
17:25:48 <elliott> Lines !Int64 !Int64 !Int64 !Int64
17:25:49 <elliott> Directed !ByteString !Int64 !Int64 !Int64 !Int64
17:25:51 <Deewiant> How do I run a Trifecta parser
17:25:56 <Deewiant> Parser**
17:26:01 <elliott> column :: HasDelta t => t -> Int64
17:26:01 <elliott> column t = case delta t of
17:26:01 <elliott> Columns c _ -> c
17:26:01 <elliott> Tab b a _ -> nextTab b + a
17:26:02 <elliott> Lines _ c _ _ -> c
17:26:04 <elliott> Directed _ _ c _ _ -> c
17:26:14 <elliott> Can't find nextTab's definition :P
17:26:14 <elliott> Oh
17:26:15 <elliott> Hmm
17:26:18 <elliott> No, still can't
17:26:23 <elliott> nextTab :: Int64 -> Int64
17:26:23 <elliott> nextTab x = x + (8 - mod x 8)
17:26:27 <elliott> Deewiant: Sorry, it makes assumptions :P
17:26:32 <Guest16962> WTFWTF HOW AM I GUEST
17:26:32 <elliott> But you could write your own Delta functions
17:26:33 -!- Guest16962 has changed nick to Gregor.
17:27:05 <elliott> Deewiant: http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/Text-Trifecta-Parser-ByteString.html seems to be the absolute-highest-level interface
17:27:21 <ais523> <elliott> nextTab x = x + (8 - mod x 8)
17:27:23 <Deewiant> I don't have a file
17:27:24 <elliott> Which uses...
17:27:25 <ais523> elliott: I approve of this definition
17:27:33 <elliott> ais523: I'm uninterested in your approval
17:27:42 <elliott> Deewiant: http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/src/Text-Trifecta-Parser-ByteString.html#parseFromFileEx
17:27:49 <elliott> There is probably an easier way than that if you don't care about efficiency
17:28:02 <Deewiant> That's what one would hope
17:28:06 <Gregor> Publishing a research paper = apparently the best bug report.
17:28:10 <elliott> I dunno, ask edwardk :P
17:28:14 <Gregor> Opera fixed a bug I mentioned in a paper :P
17:29:05 <Deewiant> I guess parseTest will do for now
17:30:47 <elliott> Hmm, I should write that n-gram stuff
17:31:49 <elliott> 07:26:38: <Patashu> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs
17:31:53 <elliott> oh, patashu isn't here
17:32:00 <elliott> or i'd give a better explanation than cakeprophet's terrible one
17:32:07 <Deewiant> Hmm, is writing a custom Rendering more work than rewriting the 20 lines of Parsec needed to handle tabs more nicely
17:32:28 <elliott> Deewiant: I don't know, let me read the source for you
17:32:43 <Deewiant> I've been reading the source, you don't really need to answer that
17:32:45 -!- DHeadshot has quit (Read error: Connection reset by peer).
17:32:45 <Deewiant> I'm just musing
17:32:52 <elliott> It was a: joke
17:34:27 <elliott> 08:58:38: <CakeProphet> !addinterp monqy haskell import Data.Char;import Control.Monad putStrLn =<< fmap toLower getContents
17:34:28 <elliott> forgot semicolon
17:34:38 <Deewiant> One wonders how many of these instances are necessary
17:34:48 <elliott> !addinterp monqy haskell import Data.Char; main = mapM_ (putChar . toLower) getContents
17:34:48 <EgoBot> ​Interpreter monqy installed.
17:34:52 <elliott> !monqy HELLO WORLD
17:34:56 <elliott> Deewiant: Which ones
17:34:58 <elliott> The Yoneda crap?
17:35:09 <Deewiant> The instances for Diagnostic, Rendering, and Delta
17:35:17 <Deewiant> All of which I'd have to copy and customize
17:35:22 <elliott> !addinterp monqy haskell import Data.Char; main = getConetnts >>= mapM_ (putChar . toLower)
17:35:22 <EgoBot> ​There is already an interpreter for monqy!
17:35:26 <elliott> Deewiant: Probably very few of them are necessary
17:35:39 <elliott> But it wouldn't be an edwardk package without all sorts of ridiculous theory dependencies
17:35:48 <Deewiant> True enough
17:35:52 -!- ais523 has quit (Remote host closed the connection).
17:36:12 <Deewiant> I hate these gratuitous imports :-/
17:36:18 <Deewiant> hiding is such a misfeature
17:36:29 <elliott> How is hiding a misfeature
17:36:59 <Deewiant> I prefer reading code where one can tell from within the file where all the identifiers are from
17:37:25 <elliott> Deewiant: So how would one use e.g. Control.Category
17:37:30 <elliott> import Prelude (HUGEST LIST EVER)?
17:37:46 <Deewiant> Okay, I suppose Prelude can be excepted
17:38:06 <Deewiant> But import X hiding (Y) where X /= Prelude should totally be an error
17:38:08 <elliott> Deewiant: What about Data.List, it has clashes with superior Foldable/Traversable variants IIRC
17:38:20 <Deewiant> import Data.List (what you need)
17:38:33 <elliott> Deewiant: So import Data.List (HUGEST LIST EVER) then
17:38:47 <Deewiant> Most of Data.List is in Prelude
17:39:05 <elliott> My real response is that special-casing Prelude is uglier than misuse of hiding :P
17:39:09 <Deewiant> This is 378 lines and it uses exactly foldl'
17:39:22 <Deewiant> Yeah, I know
17:39:26 <Deewiant> It still sucks though :-P
17:40:29 <elliott> Deewiant: There were people who would rather "import M" gave an error as well as anything using hiding
17:40:32 <elliott> I think they're mad though
17:40:40 <elliott> (As opposed to explicitly listing every use or importing qualified)
17:40:55 <Deewiant> I wouldn't mind e.g. Hackage enforcing that on upload
17:41:03 <elliott> It increases forwards-compatibility and modularity at the expense of being a huge pain in the arse
17:41:05 <Deewiant> For tinkering convenience making it an error is a bit nasty though
17:41:11 <elliott> Huge pain in the arses are never acceptable
17:42:48 <elliott> import Prelude hiding (catch)
17:42:48 <elliott> import Data.Char
17:42:48 <elliott> import qualified Data.Map as Map
17:42:48 <elliott> import qualified Data.Vector as V
17:42:48 <elliott> import Data.ByteString (ByteString)
17:42:49 <elliott> import Control.Exception
17:42:50 <elliott> import Control.Monad.State.Strict
17:42:52 <elliott> import Control.Applicative
17:42:54 <elliott> import System.IO.Error hiding (catch)
17:42:56 <elliott> Oh noes, Shiro breaks Deewiant's rules
17:43:20 <Deewiant> Well, the Prelude is also too small for comfort ;-)
17:43:40 <elliott> Deewiant: System.IO.Error is the problem there
17:43:56 <Deewiant> Basically everything in my .ghci should be in the Prelude
17:44:05 <Deewiant> :m +Control.Applicative Control.Arrow Control.Monad Control.Monad.Loops Data.Bits Data.Char Data.Either Data.Function Data.Functor Data.List Data.List.Split Data.Maybe Data.Monoid Data.Ord Debug.Trace Numeric Text.Printf
17:44:11 <Deewiant> Except for Debug.Trace
17:44:17 <elliott> I would ragequit haskell if Control.Arrow ended up in the Prelude.
17:44:21 <Deewiant> Why
17:44:27 <elliott> I don't like arrows.
17:44:34 <Deewiant> That's a silly reason
17:44:35 <elliott> I would be fine with its combinators specialised to functions, though
17:44:45 <elliott> No it isn't, I /really/ don't like arrows
17:44:52 <Deewiant> Yeah, really we should have Data.Tuple with equivalents
17:44:55 <Deewiant> (And that in the Prelude)
17:45:07 <elliott> What about +++ and ||| :P
17:45:09 <elliott> I use them literally ALL
17:45:09 <elliott> THE
17:45:10 <elliott> TIME
17:45:12 <elliott> (all the time == never)
17:45:16 <Deewiant> ?ty (+++)
17:45:17 <lambdabot> forall (a :: * -> * -> *) b c b' c'. (ArrowChoice a) => a b c -> a b' c' -> a (Either b b') (Either c c')
17:45:22 <Deewiant> Oh yeah, ArrowChoice
17:45:31 <elliott> Data.Either I guess :P
17:45:36 <elliott> Oh, Text.Printf also should not be in the prelude
17:45:42 <elliott> At all
17:45:49 <Deewiant> Yeah true
17:46:00 <elliott> I would be fine with a properly-typed formatter combinator library though ;-)
17:46:04 <Deewiant> It's only one identifier to import anyway :-P
17:46:15 <elliott> Clearly I should finish mine and propose it be added to base
17:46:44 <elliott> Data.Bits and Control.Monad.Loops I'm not to keen on either
17:46:51 <elliott> Latter should be rolled into Control.Monad though, definitely
17:47:00 <elliott> Data.Bits is really a specialised usecase though
17:47:20 <Deewiant> import Prelude as P
17:47:22 <Deewiant> Gah
17:48:05 <Deewiant> Maybe it is, but when you use one part of it you tend to use all of it, and it's reasonably common
17:48:14 <elliott> So...
17:48:16 <elliott> import Data.Bits
17:48:28 <Deewiant> >_<
17:48:35 <elliott> What
17:48:38 <elliott> It doesn't conflict with anything
17:48:43 <elliott> When you use one part of it you tend to use all of it
17:48:46 <elliott> And it's a specialised usecase
17:48:52 <elliott> So one simple unqualified import line :P
17:49:00 <elliott> I've used Data.Bits in maybe like five files out of hundreds
17:49:27 <Deewiant> Ditto for Data.Monoid, but ++ should still be from there
17:49:39 <elliott> Monoids aren't a "specialised usecase"
17:49:48 <elliott> You use them all the time, see: every "empty" and "append" function used ever
17:50:08 <elliott> You might not define monads all that often either, but that doesn't mean you don't use them in every program that isn't "main = interact f" :P
17:50:11 <Deewiant> import Control.Applicative
17:50:11 <Deewiant> import Control.Comonad
17:50:11 <Deewiant> import Control.Monad.State
17:50:11 <Deewiant> import Data.Array
17:50:11 <Deewiant> import Data.ByteString as B hiding (groupBy, empty, any)
17:50:13 <Deewiant> import Data.Foldable
17:50:16 <Deewiant> import Data.Function (on)
17:50:18 <Deewiant> import Data.Int (Int64)
17:50:21 <Deewiant> import Data.Functor.Bind
17:50:23 <Deewiant> import Data.List (groupBy)
17:50:26 <Deewiant> import Data.Semigroup
17:50:29 <Deewiant> import Data.Semigroup.Foldable
17:50:31 <Deewiant> import Data.Semigroup.Traversable
17:50:34 <Deewiant> import Data.Traversable
17:50:36 <Deewiant> import Text.Trifecta.IntervalMap
17:50:39 <Deewiant> import Prelude as P
17:50:41 <Deewiant> import Prelude hiding (span)
17:50:41 <elliott> import Edward.Kmett.Prelude
17:50:44 <Deewiant> import System.Console.Terminfo.Color
17:50:46 <Deewiant> import System.Console.Terminfo.PrettyPrint
17:50:49 <Deewiant> import Text.PrettyPrint.Free hiding (column)
17:50:51 <Deewiant> import Text.Trifecta.Rope.Bytes
17:50:54 <Deewiant> import Text.Trifecta.Rope.Delta
17:50:56 <Deewiant> import Text.Trifecta.Highlight.Class
17:50:58 <Deewiant> import Text.Trifecta.Highlight.Effects
17:51:01 <Deewiant> import qualified Data.ByteString.UTF8 as UTF8
17:51:04 <Deewiant> Where's <>
17:51:05 <elliott> That would be like six lines with Edward.Kmett.Prelude
17:51:12 <elliott> <> is semigroup I think
17:51:21 <elliott> Or uh semigroupoids
17:51:24 <elliott> What's the difference
17:51:27 <elliott> No, not semigroupoids
17:51:30 <elliott> Semigroups
17:51:33 <elliott> http://hackage.haskell.org/packages/archive/semigroups/0.8/doc/html/Data-Semigroup.html
17:51:42 <copumpkin> wat
17:51:42 <Deewiant> Where's <+>
17:51:54 <elliott> Hmm, <+> is probably...
17:52:04 <elliott> Data.Semigroup.Foldable or Data.Semigroup.Foldable
17:52:14 <Deewiant> Wrong
17:52:21 <elliott> Hmmm
17:52:25 <elliott> Oh, probably Control.Comonad
17:52:27 <Deewiant> Not Data.Semigroup.Traversable either
17:52:29 -!- DH____ has joined.
17:52:37 <Deewiant> Nope, not Comonad
17:52:41 <elliott> xNo wait
17:52:42 <elliott> Data.Functor.Bind
17:52:48 <elliott> Where the hell ist hat on Hackage
17:52:56 <Deewiant> Nope, not there
17:53:04 <elliott> Oh wait
17:53:07 <elliott> I know <+>
17:53:07 <elliott> Duh
17:53:14 <elliott> It's from the spj prettyprinter library thing
17:53:22 <elliott> It'll be the ANSI terminal derivative used there
17:53:26 <Deewiant> Ah
17:53:32 <Deewiant> Text.PrettyPrint.Free, got it
17:53:48 <elliott> Deewiant: In fairness, importing everything used from the prettyprinting library would be a pain
17:53:56 <elliott> copumpkin: wat?
17:54:01 <copumpkin> wat
17:54:05 <elliott> copumpkin: wat?
17:54:05 <copumpkin> thom
17:54:07 -!- Taneb|Hoverpack has changed nick to Taneb.
17:54:12 <elliott> copumpkin: wat?
17:54:16 <copumpkin> http://en.wikipedia.org/wiki/Angkor_Thom
17:54:18 <Deewiant> import Text.PrettyPrint.Free (Pretty(pretty, prettyList), vsep, (<+>), nest, indent, columns, align, hcat)
17:54:22 <Deewiant> Not really
17:54:25 <elliott> copumpkin: wat?
17:54:33 <Deewiant> Where's window
17:54:39 <elliott> Show me the usage
17:54:43 <copumpkin> http://en.wikipedia.org/wiki/Angkor_Wat
17:54:47 <elliott> copumpkin: I'm aware
17:54:48 <Deewiant> (lo, hi) = window (column d) ll (min (max (cols - 2) 30) 200)
17:55:05 <Deewiant> Oh, it's in there
17:55:20 <elliott> Guesses: Text.Trifecta.IntervalMap, Text.Trifecta.Rope.Delta, Text.Trifecta.Highlight.{Class,Effects},
17:55:28 <elliott> Data.Functor.Bind
17:55:29 <elliott> One of those
17:55:31 <elliott> Oh
17:55:32 <Deewiant> Text.Trifecta.Diagnostic.Rendering.Prim
17:55:35 <elliott> Fuck you :P
17:55:58 <elliott> But seriously, what's Data.Functor.Bind
17:56:04 * elliott hayoos it
17:56:09 <elliott> Oh, it's in semigroupoids
17:56:44 <elliott> "A Monad sans return."
17:56:46 <elliott> The most useful
17:56:56 <elliott> (Okay, it /is/ fairly useful)
17:57:48 <elliott> "Neil Bickford calculated the first 458 million terms for the continued fraction of pi, breaking the previous record of 180 million. He used Mathematica to develop his code and verify his results—which he posted shortly after he turned 13." --Wolfram blog
17:57:52 <elliott> "On October 17th, I calculated approximately 458,000,000 terms of pi in about 3 hours on a 64-bit machine running Windows on a Core 2 Duo @ 3.00 GHz. This was later verified using Mathematica…. The program was coded in C#, has a command-line interface (with menus!), and uses Emil Stefanov’s wrapper of GNU MP for the BigInteger multiplications." --the author of the code
17:58:00 <elliott> "used Mathematica to develop his code" indeed
17:58:52 <Deewiant> The guy also isn't as clever as everybody seems to think
17:59:42 <Deewiant> He essentially did some brute-forcing, hooray?
18:00:06 <Deewiant> Like the sliding puzzle thing
18:00:11 <elliott> http://nbickford.wordpress.com/ seems to be a better argument for his intelligence than calculating a continued fraction :-P
18:00:15 <Deewiant> The toughest puzzle he’s found so far—the one pictured above—takes 132 moves to solve, although Bickford still needs to verify the result. To get the solution, he generated every possible puzzle in Mathematica, and then solved them all in another program. It took 48 days to run, so he’d like to speed up that computation.
18:00:23 <elliott> Not that I've done everything but a bunch page downs
18:00:27 <elliott> s/everything/anything/
18:01:00 <Deewiant> I mean his not stupid but he's not anything /special/ either, other than that he's atypically young
18:01:03 <Deewiant> he's*
18:01:13 <Deewiant> Damn, I don't think I've ever managed that typo
18:01:54 <elliott> Well, it's more "this doesn't prove he's anything special", not "he's not anything special", no? I mean, bruteforcing something doesn't mean you're not intelligent otherwise
18:02:07 <Deewiant> Yes, of course
18:02:28 <Deewiant> I was speaking only in terms of the info in the Wolfram blog post
18:02:32 <elliott> Right
18:02:48 <elliott> Apparently Gosper tutors him... although my source here is Quadrescence's reddit account so take that with the fewest grains of salt you have in your collection of salt
18:03:51 <elliott> Now I shall prove my superiority to this fucking whippersnapper by writing some Markov chains
18:04:15 -!- DH____ has quit (Ping timeout: 260 seconds).
18:04:57 <elliott> Actually that sounds boring, I'll just stare at this shiro code and watch people on IRC instead
18:05:01 <elliott> This is how you get ahead
18:05:21 <Deewiant> Wow, Data.Sequence use
18:05:26 <elliott> What of it
18:05:29 <Deewiant> I don't think I've ever actually seen anything use it
18:05:40 <elliott> I use it fairly often because oerjan tells me to
18:05:50 <Deewiant> What do you use it for
18:05:54 <elliott> It's used for the ropes in Trifecta IIRC
18:05:58 <elliott> Deewiant: I don't remember my programs
18:06:07 <Deewiant> Meh
18:06:09 -!- boily has quit (Ping timeout: 252 seconds).
18:06:31 <elliott> Deewiant: Data.Sequence is literally just a rope done with finger trees, so ostensibly it should be suitable for just about anything
18:06:46 <Deewiant> Yeah, pretty much
18:06:58 <Deewiant> In practice people seem to just use [] or something very specialized
18:07:03 <elliott> Deewiant: I wouldn't mind [] becoming Seq :-)
18:07:17 <elliott> Although we'd really need pattern synonyms
18:07:19 <elliott> So you could say
18:07:27 <elliott> pattern x:xs = viewl -> x |> xs
18:07:51 <elliott> Hmm, I might have to write Shiro 2 soon; this code is starting to irritate me
18:08:27 -!- nooga_ has joined.
18:08:49 <elliott> I'm not really sure how to optimise it beyond the fungespace at this point
18:09:24 <Deewiant> You'd use pattern guards or view patterns, I guess
18:09:30 <elliott> To optimise Shiro?
18:09:39 <Deewiant> No, instead of pattern synonyms
18:09:47 <Deewiant> If you can optimize Shiro with them I commend you
18:09:52 <elliott> Deewiant: Ehh, I'd rather pattern synonyms just be added
18:10:00 <elliott> she has them, so it's exactly hard to implement :P
18:10:02 <elliott> erm
18:10:04 <elliott> she has them, so it's not exactly hard to implement :P
18:10:20 <Deewiant> Overloading always worries me :-P
18:10:27 <elliott> Deewiant: Overloading howso?
18:10:54 <Deewiant> The : in x:xs
18:10:57 <elliott> Erm, <elliott> pattern x:xs = viewl -> x |> xs should be:
18:11:06 <elliott> pattern x:xs = viewl -> x :< xs
18:11:11 -!- nooga has quit (Ping timeout: 260 seconds).
18:11:20 <elliott> Deewiant: You mean because it can't be used in expressions?
18:11:46 <elliott> I'd require a function definition for every pattern guard, with the obvious isomorphism property being expected of the programmer
18:12:16 <Deewiant> Okay at this point I'm going to state that I don't think I understand what you mean in that pattern x:xs line
18:12:27 <elliott> f (x:xs) = ...
18:12:28 <elliott> -->
18:12:32 <elliott> f (viewl -> x :< xs) = ...
18:12:41 <Deewiant> Isn't that exactly a view pattern?
18:12:51 <elliott> No? The closest you can get is the latter
18:12:57 <elliott> Or equivalently, (uncons -> (x,xs))
18:13:03 <Deewiant> Yeah, okay
18:13:09 <elliott> In fact, you'd need
18:13:10 <Deewiant> So how is : defined for the above
18:13:13 <elliott> (uncons -> Just (x,xs))
18:13:20 <elliott> Deewiant: By the pattern
18:13:25 <elliott> You'd do something like
18:13:26 <elliott> (:) :: a -> [a] -> [a]
18:13:26 <elliott> (:) = (|>)
18:13:26 <elliott> pattern x:xs = viewl -> x :< xs
18:13:40 <elliott> Most of the time, the value and pattern definition would be the same
18:13:48 <elliott> So I agree being "able" to define them separately is a wart in some sense
18:13:56 <elliott> But if you restrict them, you can't e.g. do exactly that ;-)
18:14:06 <elliott> Since the first element of a Seq doesn't correspond to a traditional pattern
18:14:10 <Deewiant> The function (:) can't be defined as part of [] as usual?
18:14:20 <Deewiant> Or did you mean [a] = Seq a there
18:14:31 <elliott> Deewiant: Yes, that's what I'm saying; to make [] a Seq, we'd need pattern syonyms
18:14:32 <elliott> synonyms
18:14:38 <elliott> Or they'd be a pain to use
18:14:44 <elliott> (Or a special case in the compiler but ugh)
18:14:52 <Deewiant> So you wouldn't have [] as it is now at all here
18:15:05 <elliott> Data.LinkedList
18:15:16 <Deewiant> Right, that's what tripped me up
18:15:21 <elliott> Right
18:15:43 <elliott> You need pattern synonyms to process any kind of complex AST really
18:15:44 <Deewiant> I thought you'd have (:) as usual in addition to that (:)
18:15:52 <elliott> (Try writing a Language.C program if you don't believe me)
18:16:12 <Deewiant> Language.C?
18:16:16 <elliott> Also for things like Mu-recursive data types to use generic annotations and the like (again an AST being the motivating example
18:16:17 <elliott> )
18:16:29 <elliott> Deewiant: http://hackage.haskell.org/package/language-c
18:16:37 <elliott> It's a framework for processing/analysing/transforming C99 code
18:16:44 <elliott> It's wonderful but dear god the AST is a pain to match on
18:16:55 <elliott> For instance
18:17:03 <elliott> transformItem :: GCTypeInfo -> CBlockItem -> State (Set String) [CBlockItem]
18:17:03 <elliott> transformItem ti x@(CBlockDecl decl@(CDecl _ decls _)) | relevant decl && loltrace decls = do
18:17:03 <elliott> forM_ decls (\(Just (CDeclr (Just ident) _ _ _ _),_,_) -> modify (Set.insert (identName ident)))
18:17:03 <elliott> return [x, CBlockStmt (CExpr (Just (CCall (CVar (internalIdent "GGC_PUSH") internalNode) [CVar (internalIdent "foo") internalNode] internalNode)) internalNode)]
18:17:03 <elliott> where relevant (CDecl spec _ _) = any interesting spec
18:17:05 <elliott> interesting x@(CTypeSpec (CTypeDef (Ident name _ _) _)) = name `Map.member` ti
18:17:09 <elliott> interesting _ = False
18:17:11 <elliott> ...
18:17:13 <elliott> where yeah x@(CAssign op (CMember (CVar ident@(Ident name _ _) _) field True _) to ni) = do
18:17:15 <elliott> ...
18:17:25 <Deewiant> heh
18:17:26 <elliott> The previous version I had was even more deeply nested and awful
18:17:39 <Deewiant> Well, that's ASTs for you
18:17:45 <elliott> Yeah, which is why we need pattern guards :-P
18:17:46 <Deewiant> They can't really not be nested :-p
18:17:50 <Deewiant> synonyms*
18:18:24 <elliott> where yeah x@(op := (Var ident@(Ident name _ _) :. field)) = ...
18:27:52 -!- Vorpal has joined.
18:28:45 -!- MSleep has quit (Ping timeout: 260 seconds).
18:31:41 <elliott> "Why serve up the orange homage to Szent-Gyorgy today? Guessing the Googlers is a fool's errand but the folks at SearchEngineWatch do note that flu season is right around the bend." --CBS
18:31:44 <elliott> "alt="Albert Szent-Gyorgyi&#39;s 118th Birthday" title="Albert Szent-Gyorgyi&#39;s 118th Birthday"" --Google
18:37:22 <Gregor> lol, that is wildly non-mysterious :P
18:37:30 <Gregor> It's a fool's errand!
18:37:43 <Gregor> "He is credited with discovering vitamin C and the components and reactions of the citric acid cycle."
18:37:45 <Gregor> WHAT COULD IT MEAN
18:38:29 <elliott> Gregor: Well yeah, they do figure that part out in the article :P
18:38:34 <elliott> But then they're like WHY TODAY????????
18:38:37 <elliott> WHO KNOWS?????
18:39:03 -!- zzo38 has joined.
18:39:22 <Gregor> ...
18:39:23 <Gregor> lol
18:39:42 <zzo38> ...
18:39:54 <elliott> lol
18:41:46 -!- Taneb has quit (Quit: closing).
18:43:23 <zzo38> I have a copy of some of the CGA Collection games, including information about many of them (although not all of the programs)
18:43:57 <zzo38> This is the games: http://zzo38computer.cjb.net/GAMES/cgacoll1.zip
18:45:10 -!- Taneb has joined.
18:46:58 <zzo38> Do you like this games?
18:47:51 <Gregor> Copyright infringement! (Probably?)
18:48:29 <elliott> I'm pretty sure they're zzo's games.
18:48:55 <zzo38> Gregor: It is public domain.
18:49:13 <Gregor> Oh :P
18:49:31 <zzo38> And all of them source-codes available.
18:49:37 <zzo38> All are DOS games.
18:51:31 <Deewiant> Okay I've decided I can't use trifecta due to this tab business
18:52:12 <elliott> Deewiant: Are you srs
18:52:21 <Deewiant> instance Semigroup Delta where
18:52:24 <Deewiant> Tab x y a <> Tab x' y' b = Tab x (nextTab (y + x') + y') (a + b)
18:52:35 <elliott> Yeah, but I don't think Tab is actually used there
18:52:39 <elliott> Maybe it's used in the layout stuff
18:52:42 <Deewiant> It is used
18:52:51 <Deewiant> > parseTest (string "\t" >> string "x") "\ty"
18:52:51 <Deewiant> (interactive):1:9: error: expected: "x"
18:52:51 <lambdabot> Not in scope: `parseTest'Not in scope: `string'Not in scope: `string'
18:52:54 <elliott> Why does it matter so much anyway, considering that no editor on the planet considers tabs to be one column
18:53:09 <Deewiant> Because many editors on the planet consider tabs to be something other than 8 columns
18:53:26 <elliott> Yep, but if you consider them one column, it'll be useful to exactly zero people
18:53:27 <Deewiant> And it helps for the column number to match something that your editor can conveniently tell you :-P
18:53:41 <elliott> My editor can't conveniently tell me that
18:53:43 <Deewiant> Considering them one column gives you the byte offset
18:53:43 <elliott> At least I don't think it can
18:53:48 <Deewiant> Mine can
18:53:49 <elliott> Anyway, since trifecta's diagnostics show the line
18:53:53 <elliott> And draw a little arrow to the relevant part of the line
18:53:58 <elliott> I think the column number is pretty irrelevant :P
18:54:07 <elliott> <Deewiant> Considering them one column gives you the byte offset
18:54:10 <elliott> No, it gives you the codepoint offset
18:54:39 <Deewiant> Or grapheme cluster offset, depending on how Unicodey trifecta is
18:54:55 <elliott> I doubt it's that Unicodey
18:55:03 <elliott> But anyway,
18:55:04 <elliott> <elliott> Anyway, since trifecta's diagnostics show the line
18:55:04 <elliott> <elliott> And draw a little arrow to the relevant part of the line
18:55:04 <elliott> <elliott> I think the column number is pretty irrelevant :P
18:55:06 <Taneb> You what I've just noticed
18:55:12 <Deewiant> In my defence clang reports an error like that as 1:2 not 1:9
18:55:13 <Taneb> The video for Take On Me
18:55:16 <elliott> (OK, so sometimes it even highlights sections of the line rather than just using an arrow.)
18:55:16 <zzo38> Why do you need to parse tabs depending on their number of columns anyways?
18:55:19 <Deewiant> So trifecta isn't very clang-styley!
18:55:24 <elliott> Deewiant: Oh no!
18:55:26 <Taneb> Everything starts going wrong when the comic is put in the bin
18:55:31 <elliott> I don't think clang ever highlights the source code, either.
18:55:37 <Deewiant> Eh?
18:55:46 <elliott> Well, I heard murmurings that trifecta could do that.
18:55:50 <elliott> Something involving HsColour.
18:55:53 <elliott> Maybe I wrong.
18:56:07 <Deewiant> That'd probably involve telling it how to do it for whatever you're parsing
18:56:13 <elliott> Deewiant: trifecta has had two Hackage uploads today
18:56:15 <zzo38> Generally tabs use to separate fields though, such as in tab-separated-values, or in gopher menus.
18:56:20 <elliott> Deewiant: If you complained, I bet you could make that three :-P
18:56:27 <Deewiant> Eh, I doubt it
18:56:29 <zzo38> And if you can set tab stops, then use it to organize columns in anything
18:56:48 <Deewiant> I don't really have the energy to try and convince him, especially if he's like ais
18:57:01 <elliott> I doubt he's like ais, I bet he's just going by what Haskell considers
18:57:03 <elliott> Which is tab = eight spaces
18:57:12 <elliott> Because layout parsing
18:57:16 <Deewiant> And the alternative is making a very deeply-ingrained thing configurable in a small way, breaking probably half the code
18:57:26 <elliott> No it isn't, just put tabWidth in the delta
18:57:46 <zzo38> That is one problem with layout parsing of Haskell programs containing tabs. I suggest either not using tabs or not using layout.
18:57:50 <elliott> Hmm, you'd need to special case tabWidth=one because of modulo
18:57:53 <elliott> But w/e
18:57:58 <Deewiant> I don't even know where he should put tabWidth
18:58:11 <elliott> Delta
18:58:12 <Deewiant> You need to pass it from the top-level parser call methinks
18:58:26 <elliott> Aren't Deltas a monoid
18:58:35 <elliott> In which case you just need to replace wherever mempty is called
18:58:36 <Deewiant> Yes
18:58:36 <elliott> Maybe
18:58:45 <elliott> Assuming all deltas are derived from mempty
18:58:58 <Deewiant> Tab x y a <> Tab x' y' b = Tab x (nextTab (y + x') + y') (a + b)
18:59:01 <Deewiant> nextTab :: Int64 -> Int64
18:59:02 <Deewiant> nextTab x = x + (8 - mod x 8)
18:59:05 <elliott> Dude
18:59:07 <elliott> Tab is a constructor of Delta
18:59:14 <Deewiant> Yes, and
18:59:23 <Deewiant> My point is that there's a lot of Tab-unpacking :-P
18:59:25 <elliott> Tab x y a tw <> Tab x' y' b tw = Tab x (nextTab tw (y + x') + y') (a + b)
18:59:29 <elliott> Deewiant: In the instance? No shit
18:59:44 <elliott> I tend to deconstruct data types a lot from their module
19:00:05 <elliott> Anyway, I still don't think a single person will ever look at the column number if they have an arrow pointing to the relevant character
19:00:29 <Deewiant> Meh
19:00:29 <Deewiant> FINE
19:00:36 <zzo38> When I make preprocessor of Haskell, I can simply solve this problem by not parsing layout at all.
19:01:19 <elliott> Deewiant: I think zzo38 is solving your problem here
19:01:25 <elliott> You should probably implement whatever he's talking about
19:01:28 <Deewiant> No I think he's solving his own
19:01:39 <elliott> Well, aren't zzo38's problems everyone's, in some sense
19:01:44 <zzo38> Deewiant: Yes, I am solving my own
19:01:56 <zzo38> But if it helps you, then you might be able to use it. Otherwise, it don't .
19:02:58 <Deewiant> elliott: Haha, speaking of Hackage uploads today
19:03:04 <Deewiant> The docs have changed in the meanwhile
19:03:06 <Deewiant> Where's lookAhead now/
19:03:11 <Deewiant> s/\/$/?/
19:03:14 <elliott> Awesome
19:03:27 <elliott> http://hackage.haskell.org/packages/archive/trifecta/latest/doc/html/Text-Trifecta-Parser-Class.html#v:lookAhead
19:03:30 <elliott> Still where it was?
19:03:35 <Deewiant> Oh, whoops
19:03:40 <Deewiant> cabal update is a good thing to run
19:03:50 <elliott> Oh that wacky Deewiant
19:04:09 <elliott> Aw feck, I have a bunch of global GHC packages now unintentionally
19:04:17 <elliott> Time to trash 'em all
19:04:21 <Deewiant> Why is that a problem
19:04:42 <Deewiant> Whee, building 142 Haskell modules
19:04:43 <elliott> Because cabal-dev
19:04:59 <elliott> The chances of getting broken packages as t goes to infinity are one
19:05:07 <Deewiant> C++ projects are typically faster to compile than Haskell ones because at least they can build in parallel
19:05:12 <elliott> At least with cabal-dev it's easier to get working again
19:05:27 <elliott> Deewiant: You can build Haskell modules in parallel too
19:05:31 <elliott> GHC just doesn't
19:05:49 <Deewiant> If "cabal install" doesn't then I'm going to say you "can't"
19:05:59 <Deewiant> Because the alternative is slower than building serially :-P
19:06:36 <elliott> Time to bootstrap HsColour again
19:06:45 <elliott> Deewiant will now ask me what that means and why I need to do that
19:07:09 <Deewiant> Btw, if cabal-install can install source codes in the local haddock docs, please tell me how
19:07:17 <elliott> Hahaha
19:07:19 <elliott> That's why I need to do that
19:07:26 <Deewiant> It can do that these days?
19:07:31 <elliott> It has always been able to do that
19:07:35 <elliott> OK, sit down, children, and listen
19:07:38 <elliott> Here's a tutorial
19:08:29 <elliott> Deewiant: Wipe your .cabal and .ghc. Download hscolour from Hackage. runhaskell Setup.hs configure --user, build, install, clean, configure --user, build, haddock --hyperlink-source, install. Download cabal-install. Find the configure/build/install lines, and insert after build:
19:08:32 <elliott> ./Setup haddock ${VERBOSE} --hyperlink-source \
19:08:32 <elliott> || die "Building the ${PKG} package's documentation failed"
19:08:39 <elliott> Re-bootstrap
19:08:41 <elliott> Install
19:09:01 <elliott> I /think/ cabal-install automatically does haddock --hyperlink-source if you have it intsalled
19:09:27 <elliott> It would be nice if I could get highlighted source for the global base packages too, sigh
19:09:28 <Deewiant> Okay so it was more the pain of getting Haddock to work, then
19:09:36 <elliott> Well Haddock works without all that, it's just hscolour
19:09:52 <Deewiant> I have hscolour, but my haddock doesn't recognize --hyperlink-source
19:10:03 <elliott> It's not haddock
19:10:08 <elliott> It's Setup.hs haddock
19:10:13 <Deewiant> But anyway I'll replace "wipe your .cabal and .ghc" with "wait until extra/ghc switches to a new version"
19:10:26 <Deewiant> Setup.hs haddock is haddock
19:10:31 <elliott> Oh hmm
19:10:33 <elliott> You just need to do
19:10:41 <elliott> --haddock-options=--hyperlink-source on every cabal-install call, it seems
19:10:58 <elliott> Heh
19:11:09 <elliott> Maybe there's a ~/.cabal/config option for that
19:11:14 <Deewiant> Probably
19:11:16 <elliott> I guess I never actually checked to see if the source links were being generated
19:12:41 <elliott> Oh well, I'd like to keep with only one cabal-install'd package, anyway
19:12:59 <elliott> (i.e., cabal-dev)
19:13:18 -!- nooga_ has quit (Ping timeout: 260 seconds).
19:13:35 <Deewiant> http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/Text-Trifecta-Parser-It.html
19:13:45 <Deewiant> Text.Trifecta.Parser.It
19:13:46 <Deewiant> harder, better, faster, stronger...
19:13:54 <Deewiant> What the hell is this?
19:14:07 <elliott> An internal module with a Daft Punk quote as its only documentation?
19:14:09 <elliott> HTH
19:14:15 <elliott> data It r a
19:14:15 <elliott> = Pure a
19:14:15 <elliott> | It a (r -> It r a)
19:14:15 <Deewiant> It's exported
19:14:19 <elliott> Looks like an iterator of some description
19:14:31 <Deewiant> It's a cofree comonad
19:14:35 <Deewiant> That's its other documentation
19:14:41 <elliott> That's the documentation of the Comonad instance
19:14:46 <elliott> -- | Return the text of the line that contains a given position
19:14:47 <elliott> rewindIt :: Delta -> It Rope (Maybe Strict.ByteString)
19:14:54 <elliott> It's just some kind of iterator
19:18:06 <elliott> Deewiant: BTW, my official recommendation wrt parsers is that you wait until mine is out
19:18:17 -!- Wamanuz2 has quit (Remote host closed the connection).
19:18:18 <Deewiant> That's not a very useful recommendation
19:19:09 <Deewiant> How many instances will I need to make Text trifecta-Parseable, I wonder
19:19:23 <elliott> Don't, just use ByteStrings, it parses UTF-eight
19:19:33 <elliott> Supposedly it's fast
19:19:52 <elliott> Deewiant: Anyhow, don't you /want/ a derivative-based (so it supports any CFG, including left-recursive ones, efficiently in practice) parser combinator library that supports incremental input (like all the fancy libraries do these days) library with hopefully nice diagnostics????
19:20:28 -!- Taneb has quit (Ping timeout: 240 seconds).
19:20:57 <Deewiant> But Data.Text has toCaseFold, it's all Unicodey
19:21:02 <elliott> s/list of advantages of derivative-based parsers/that list, plus (<|>) being commutative/
19:21:28 <elliott> Deewiant: If you use it in your parser, why not just create the relevant text for the snippet inside the parser
19:21:31 <zzo38> I used Parsec to make parsing in Haskell
19:21:41 <elliott> OK, that's probably slow :P
19:21:45 <elliott> Well
19:21:47 <elliott> Maybe not that slow
19:21:51 <Deewiant> http://abstrusegoose.com/_007297.htm
19:22:19 <Deewiant> I'm not really tied to any particular string type at this point
19:22:36 <Deewiant> Data.Text just looked like "the hot new thing"
19:22:52 <elliott> Data.Text.Text is my perfectprelude's String
19:23:03 <elliott> (perfectprelude as in what you were saying needs to go into Prelude, not something that actually exists)
19:23:10 <elliott> Well
19:23:11 <Deewiant> It has O(n) cons
19:23:11 <elliott> That's a lie
19:23:16 <Deewiant> That makes it kinda annoying
19:23:17 <elliott> I want all the functions and properties
19:23:20 <elliott> But a better implementation
19:23:24 <elliott> i.e.
19:23:25 <elliott> A rope :)
19:23:31 <Deewiant> Meh, ByteString it is
19:23:34 <Deewiant> How old-fashioned
19:23:40 -!- Wamanuz has joined.
19:23:45 <elliott> Something like... a rope of what is Text now
19:23:50 <elliott> Except UTF-eight
19:23:58 <coppro> +++++
19:23:58 <elliott> With the lengths cached properly
19:24:00 <elliott> i.e. not length in bytes
19:24:02 <elliott> coppro: What
19:24:02 <coppro> +++++++++++++++
19:24:03 <Deewiant> Either ISO88591 UTF32
19:24:14 <elliott> Deewiant: I vomited
19:24:25 <Deewiant> I doubt it
19:24:34 <elliott> My IRC persona did
19:24:39 <Deewiant> Something I ran into recently used that, I can't remember what it was
19:24:43 <Deewiant> (Might not have been Haskell)
19:25:07 <elliott> Ooh, I know how to speed Shiro up; cabal-dev install --ghc-opts="-O2"
19:25:13 <elliott> Then all my dependencies will get MOAR OPTIMISATION
19:25:26 <elliott> I'm so glad nobody mature is in here to tell me how stupid that is
19:25:29 <Deewiant> Doesn't cabal-install do that by default?
19:25:47 <Deewiant> -- optimization: True
19:25:50 <Deewiant> I imagine that means something
19:25:52 <elliott> cabal defaults to -O1 nowadays because -O2 is slow
19:25:57 <elliott> And doesn't help much for most things
19:26:02 <elliott> much ~ at all
19:26:07 <Deewiant> Meh, that sucks
19:26:16 <elliott> You were just complaining about how slow Haskell building was
19:26:36 <Deewiant> But MOAR OPTIMIZATION, dude
19:26:54 -!- oerjan has joined.
19:27:01 <zzo38> GHC is written in Haskell, so if they fix it to run faster (and possibly, less memory; this result in less page faults too), then it should compile faster, too.
19:27:02 <Deewiant> But I was also referring to -O2 not helping much
19:27:15 <Deewiant> Do the new GHCs use -fllvm by default yet?
19:27:17 -!- monqy has joined.
19:27:24 <elliott> Define new
19:27:33 <Deewiant> Darcs head
19:27:39 <Deewiant> Or git head, these days
19:27:39 <elliott> Fucked if I know
19:27:43 <oerjan> istr -O2 only gives marginal improvement over -O
19:27:46 <elliott> I don't think 7.0.4 does, but seven-point two might
19:27:49 <elliott> I'll ask the channel
19:27:54 <Deewiant> I know 7.0.x doesn't
19:28:05 <Deewiant> It doesn't even work on Arch because it depends on an old LLVM
19:28:38 <elliott> When my laptop gets back (after I send my laptop off >_>) I think I'll get me a shiny new SVN LLVM + GHC 7.2
19:28:46 <elliott> It'll be like Christmas
19:28:52 <elliott> Maybe shiro will even speed up, rather than slow down
19:29:14 <elliott> <parcs> no
19:29:16 <elliott> Deewiant: no
19:29:32 <oerjan> <elliott> When my laptop gets back <-- oh, so you finally --> (after I send my laptop off >_>) <-- oh, never mind.
19:29:36 <Deewiant> Shameful
19:29:40 <zzo38> The more -O results in a larger LLVM program, from what I tried.
19:29:42 <elliott> SpecConstr
19:29:42 <elliott> Function `a_soBN{v} [lid]'
19:29:42 <elliott> has two call patterns, but the limit is 1
19:29:42 <elliott> Use -fspec-constr-count=n to set the bound
19:29:42 <elliott> Use -dppr-debug to see specialisations
19:29:43 <elliott> SpecConstr
19:29:45 <elliott> Function `a_soBN{v} [lid]'
19:29:48 <elliott> has two call patterns, but the limit is 1
19:29:49 <elliott> Use -fspec-constr-count=n to set the bound
19:29:52 <elliott> Use -dppr-debug to see specialisations
19:29:53 <elliott> SpecConstr
19:29:54 <Deewiant> That's GHC 7.0.x for you
19:29:55 <elliott> Function `$j_soCK{v} [lid]'
19:29:57 <Deewiant> It prints that
19:29:57 <elliott> has six call patterns, but the limit is 3
19:29:58 <oerjan> </actual thought process>
19:30:00 <elliott> Use -fspec-constr-count=n to set the bound
19:30:01 <elliott> Use -dppr-debug to see specialisations
19:30:03 <elliott> I loooooooooove how you can't turn these off
19:30:05 <elliott> At all
19:30:07 <elliott> Because they're not actually warnings, the specialiser just prints them out
19:30:09 <elliott> oerjan: :-)
19:30:09 <Deewiant> Use grep
19:30:33 <elliott> I wish they were printed as warnings, but without the typical warning guard, so that -Werror failed on them
19:30:36 <elliott> That's the only way they could be more annoying
19:30:46 <elliott> By wish I mean, like, I don't know, it would be cosmically appropriate
19:30:48 <Deewiant> Man, people should use Data.Pointed more
19:30:54 <elliott> Why
19:30:57 <Deewiant> So that I could include it instead of other things
19:31:00 <Deewiant> import*
19:31:03 <elliott> I thought you were annoyed at Kmett's massive import list
19:31:08 <Deewiant> I am
19:31:10 <elliott> But no, you want more Kmett imports, more
19:31:13 <elliott> Moooore
19:31:23 <elliott> Kmetskell does not have the same ring to it.
19:31:25 <Deewiant> I want FingerTree to use it, actually
19:31:26 <elliott> s/t/tt/
19:31:39 <elliott> Deewiant: Which FingerTree
19:31:48 <elliott> Kmett has one :-)
19:31:49 <elliott> I think
19:31:58 <Deewiant> He uses Data.FingerTree in trifecta
19:32:00 <elliott> Oh
19:32:01 <elliott> Probably not then
19:32:08 <elliott> He has a priority queue, which is close enough right?
19:32:28 <Deewiant> Evidently just using a Trifecta parser requires using a FingerTree, a Rope, a UTF8 ByteString, and an ordinary ByteString
19:32:38 <elliott> A "UTF8 bytestring"?
19:32:39 <Deewiant> Oh, the UTF8 is just for the file name
19:32:45 <elliott> That's called a ByteString with a certain type of data inside it
19:32:49 <Deewiant> Whatever man
19:32:58 <Deewiant> Add "module" to the end of the line if you want
19:33:07 <elliott> Deewiant: BTW, you said Text has O(n) cons and the like, but it's pretty much the same internally as ByteString, which has the same problems
19:33:16 <elliott> For ByteString it's probably ok because of the use-case, though
19:33:19 <Deewiant> I was comparing it to String at that time
19:33:54 <elliott> Text doesn't even do "when we grow, grow too much for speculative future use" I think because that's a pain for functional languages for some reason I don't recall
19:34:09 <elliott> So everything that's O(n) really is O(n), every single time, always
19:34:15 <zzo38> I would like to be able to use Template Haskell to generate declarations even if it is not a declaration splice.
19:35:36 <elliott> Hey Deewiant, what's a good name for Vector a -> [(Int, a -> a)] -> Vector a
19:36:09 <elliott> i.e. f v xs = v // map (\(k,f) -> (k, f (v!k)) xs
19:36:43 <oerjan> <hagb4rd> german-elite.net#gulli
19:36:47 <oerjan> sounds scary
19:36:54 <Deewiant> apply'Em
19:37:15 <hagb4rd> oerjan: it is
19:37:24 <oerjan> O KAY THEN
19:37:31 <Deewiant> elliott: apply'Em
19:37:32 <elliott> Deewiant: What
19:37:36 <elliott> Why
19:37:37 <elliott> That
19:37:38 <elliott> Is the worst name
19:37:42 <Deewiant> It's like applyThem but apply'Em
19:37:48 <elliott> It isn't applyThem either
19:38:01 <Deewiant> I know, I just can't think of anything really good so I went with something really bad and apostrophy
19:38:05 <monqy> apply'em is better than apply'Em but still bad
19:38:09 <elliott> I was thinking (%%) or (//%) or update
19:38:19 <elliott> Or even modifyV
19:38:25 <Deewiant> //% reminds me of mathematica
19:38:37 <elliott> Data.Vector.(//) does that in the first place
19:38:38 <elliott> To me
19:38:44 -!- MSleep has joined.
19:38:46 <Deewiant> //% would work for me
19:38:58 <elliott> http://permalink.gmane.org/gmane.comp.lang.agda/3127 Oh dear god, Agda is now in our browsers, using FRP
19:40:46 <elliott> modifyFPInstructions $ \v -> v //% map (\ins -> (fromEnum ins, tail)) instructions
19:40:46 <elliott> d
19:40:49 <elliott> Deewiant: Yeah that's fairly good
19:40:54 <MSleep> What's Adga?
19:41:02 <zzo38> One use of more-notation, is that haskell-src-exts has too much duplication of everything: data PExp l = Var l (QName l) ... ann e = case e of Var l qn -> l ...
19:41:11 <MSleep> Asking WIkipedia got me "American Dairy Goat Association".
19:41:17 -!- MSleep has changed nick to MDude.
19:41:43 <elliott> MDude: A dependently-typed purely-functional programming language/proof system.
19:41:48 <MDude> No wonder, I got the g and a switched.
19:42:02 <zzo38> The other one, is, pretend MSE is actually Haskell and doens't have impure functions: data Card = Card { more CardFields, cardStyle :: Maybe Style }; data Style = more Styles; renderStyle :: Style -> Render (); renderStyle s = case s of more StyleRenderers;
19:42:15 -!- sllide has quit (Ping timeout: 260 seconds).
19:42:38 <elliott> modifyFPInstructions $ \v ->
19:42:38 <elliott> let (aSem, aSems) = let x:xs = v V.! fromEnum a in (x, bSem:xs)
19:42:38 <elliott> (bSem, bSems) = let x:xs = v V.! fromEnum b in (x, aSem:xs)
19:42:38 <elliott> in v V.// [(fromEnum a, aSems), (fromEnum b, bSems)]
19:42:38 <elliott> Oh dear, this could be complicated
19:42:45 <monqy> zzoskelle is scary
19:42:54 <elliott> Mutual recursion, isn't it great
19:43:06 <Deewiant> import Control.Applicative ( (<$>), (<|>), (<*), (*>), (<*>)
19:43:06 <Deewiant> , (<**>), pure, empty, optional
19:43:06 <Deewiant> , liftA2)
19:43:10 <Deewiant> Who said importing what you use is a pain
19:43:21 <elliott> Deewiant: I call that a pain
19:43:22 <zzo38> Now you use orders in more-declarations to represent z-orders of rendering fields.
19:43:51 <oerjan> <Deewiant> ?hoogle Applicative f => f (a -> b) -> (b -> c) -> f (a -> c)
19:43:57 <Deewiant> (Note the less than 40 characters available for the symbols; thanks be to "Text.Trifecta.Parser.Combinators")
19:44:17 <oerjan> :t flip (fmap (.))
19:44:18 <lambdabot> forall a b (f :: * -> *) a1. (Functor f) => a1 -> (a1 -> a -> b) -> f a -> f b
19:44:30 <oerjan> argh
19:45:01 <oerjan> :t flip (fmap (.) .)
19:45:02 <lambdabot> forall a b (f :: * -> *) (f1 :: * -> *) a1. (Functor f, Functor f1) => a1 -> (a1 -> f1 (a -> b)) -> f1 (f a -> f b)
19:45:15 <Deewiant> ?ty flip ((<*>) . pure . (Prelude..))
19:45:16 <lambdabot> forall (f :: * -> *) b c a. (Applicative f) => f (a -> b) -> (b -> c) -> f (a -> c)
19:45:19 <oerjan> wth is it about flip and me again
19:45:30 <oerjan> Deewiant: no, it should _not_ require Applicative
19:45:45 <elliott> I really wish Vector was polymorphic in the index type :-(
19:45:47 <Deewiant> ?ty flip (ap . return . (Prelude..))
19:45:48 <lambdabot> forall (m :: * -> *) b c a. (Monad m) => m (a -> b) -> (b -> c) -> m (a -> c)
19:45:57 <oerjan> Deewiant: only Functor
19:46:06 <Deewiant> I know what you meant :-P
19:46:06 <elliott> Someone make that happen, please
19:46:45 <zzo38> monqy: zzoskelle is scary?
19:46:48 <monqy> yes.
19:46:52 <monqy> zzoskelle is scary.
19:47:13 -!- CakeProphet has joined.
19:47:13 <elliott> Ha ha, I have a function here that would be made more readable with Control.Arrow but I'm not going to do it, take THAT Deewiant
19:47:13 -!- CakeProphet has quit (Changing host).
19:47:13 -!- CakeProphet has joined.
19:47:23 <Deewiant> Oh noes
19:47:28 <Deewiant> I am wounded!
19:47:43 <oerjan> :t (fmap (.) .)
19:47:44 <lambdabot> forall a b (f :: * -> *) (f1 :: * -> *) (f2 :: * -> *). (Functor f, Functor f1, Functor f2) => f2 (f1 (a -> b)) -> f2 (f1 (f a -> f b))
19:47:47 -!- Taneb has joined.
19:47:53 <oerjan> i think someone should assassinate Cale.
19:48:04 <oerjan> :t (fmap (Prelude..) Prelude..)
19:48:05 <Deewiant> It's pretty clearly flip (.:)
19:48:05 <lambdabot> forall b c a (f :: * -> *) a1. (Functor f) => (a1 -> f (b -> c)) -> a1 -> f ((a -> b) -> a -> c)
19:48:12 <Deewiant> ?ty flip (fmap fmap fmap)
19:48:13 <lambdabot> forall (f :: * -> *) a b (f1 :: * -> *). (Functor f, Functor f1) => f (f1 a) -> (a -> b) -> f (f1 b)
19:48:21 <Taneb> Cale?
19:48:25 <Deewiant> Now just substitute (Prelude..) for the appropriate fmaps
19:48:36 <Deewiant> ?ty flip (fmap fmap (Prelude..))
19:48:36 <lambdabot> forall (f :: * -> *) b c a. (Functor f) => f (a -> b) -> (b -> c) -> f (a -> c)
19:48:51 <Deewiant> ?ty flip (fmap . (Prelude..))
19:48:52 <lambdabot> forall (f :: * -> *) b c a. (Functor f) => f (a -> b) -> (b -> c) -> f (a -> c)
19:49:02 <oerjan> Taneb: the guy who modified (.) in lambdabot and gave no short way to write the original
19:49:17 <zzo38> monqy: What is it scary? What can it scares you?
19:49:31 <monqy> zzo38: the parts that are zzoskelle scare me
19:49:33 <elliott> Deewiant: P.S., please rename my Vector type, thanks
19:49:46 <zzo38> monqy: Then please be more specific and explain why.
19:49:47 <Deewiant> Wector
19:50:05 <monqy> (.) really should stop being fmap and start being (Control.Category..) also prelude-. should be category-. and same for id
19:50:24 <elliott> Deewiant: I find this a bad renaming
19:50:33 <elliott> Oh, so that's why I imported Data.Bits qualified
19:50:48 <monqy> zzo38: I'm not quite sure
19:51:08 <zzo38> monqy: Yes, I do think it make more sense. Since (.) and id in Category are still defined for the Hask category as well.
19:51:16 <elliott> Also, argh @ people who put (a -> Foo) into classes and say "YOU CAN'T EXAMINE THE VALUE LOL JUST PASS UNDEFINED"; Deewiant: You don't do that, do you?
19:51:22 -!- Taneb has quit (Remote host closed the connection).
19:51:50 <Deewiant> Is there an alternative to doing that when you have to do that? :-PP
19:51:57 <elliott> Yes
19:51:58 <oerjan> Deewiant: yes, use Proxy
19:52:02 <elliott> Proxy a -> Foo
19:52:03 <elliott> or
19:52:03 <elliott> Tagged a Foo
19:52:14 <elliott> They're in the same package and have conversion functions each way so I don't give a damn which you use
19:52:20 <zzo38> monqy: But I don't know why it can scare anyone
19:52:20 <elliott> The former lets the same source definitions keep working, though
19:52:25 <elliott> If you're fixing something broken
19:53:44 <Vorpal> if anyone loves a ultra-violence zombie game, I can recommend Dead Island. However, I personally find the violence a bit too much perhaps.
19:53:55 <elliott> Deewiant: Disabling fingerprints made Mycology go /slower/; please fix thanks
19:54:04 <Vorpal> s/loves a/loves/
19:54:10 <Vorpal> s/game/games/
19:54:17 <elliott> Vorpal: It was correct before then
19:54:21 <elliott> Although informal
19:54:27 <Deewiant> elliott: Mycology doesn't have a speed, Shiro does
19:54:30 <monqy> I've heard only good things about dead island
19:54:35 <Vorpal> elliott, yeah well that is what I got from editing it before sending it.
19:54:47 <Vorpal> elliott, even if it was correct I didn't intend it that way
19:54:49 <elliott> Heh
19:54:56 <elliott> Deewiant: I am offended
19:55:10 <Deewiant> I am okay with that
19:55:14 <Vorpal> <elliott> Deewiant: Disabling fingerprints made Mycology go /slower/; please fix thanks <-- wut
19:55:17 <elliott> Deewiant: BTW, tell me you have a backup of the RC/Funge website, or at least the fingerprints page
19:55:24 -!- Taneb has joined.
19:55:30 <Vorpal> elliott, that is opposite of my experience with cfunge and the -F switch
19:55:32 <Deewiant> The fingerprints page, yes
19:55:35 <Deewiant> Not sure how recent though
19:55:38 <Deewiant> It might be e.g. 5 years old
19:55:39 <Vorpal> so you are probably doing something wrong
19:55:40 <elliott> I rather suspect it will stop existing sometime within the next few years due to obviously being completely unmaintained
19:55:43 <elliott> Deewiant: lol
19:55:53 <elliott> Vorpal: It's within rounding error range
19:55:55 <Vorpal> elliott, I believe I have a backup, on a computer that is dual-booted to another OS atm.
19:55:59 <Vorpal> is the site down?
19:56:03 <elliott> Vorpal: No, I was just checking
19:56:10 <elliott> I'll mirror it myself for funge-archive when I get around to adding more
19:56:35 <Deewiant> It's in the wayback machine, I wouldn't worry
19:56:48 <elliott> Fair enough
19:57:30 <elliott> Does anyone (i.e. Deewiant or oerjan) have a nicer way of writing
19:57:34 <elliott> let (aSem, aSems) = let x:xs = v ! a in (x, bSem:xs)
19:57:35 <elliott> (bSem, bSems) = let x:xs = v ! b in (x, aSem:xs)
19:57:36 <elliott> in v // [(a, aSems), (b, bSems)]
19:57:37 <Vorpal> elliott, oh and downside with dead islands: load screen takes ages. Sure I'm using a slightly older hdd for windows, but 15 minutes is *absurd*
19:57:39 <elliott> I mean, I find it kind of elegant
19:57:41 <elliott> Just wondering
19:57:41 <Vorpal> and one*
19:57:44 <Deewiant> Also argh, can I tell firefox to not URL-escape stuff when expanding keyworded bookmark
19:57:47 <Deewiant> +s
19:58:02 <Taneb> Done some more work on Salesman
19:58:27 <Vorpal> <Deewiant> It's in the wayback machine, I wouldn't worry <-- not the binary files though?
19:59:17 <zzo38> How can they make compiled Haskell programs smaller? There could be some mode to tell it assume not to have errors, to compile it in that way by option
19:59:37 <Sgeo> islands?
20:00:03 <Deewiant> Noo System.Console.TermInfo.PrettyPrint
20:00:06 <Sgeo> zzo38, that sounds more likely to make compilation faster than to make the resulting binary smaller
20:00:12 <Deewiant> Why must you be even longer than Text.Trifecta.Parser.Combinators
20:00:21 <elliott> Deewiant: What are you even doing
20:00:22 <Sgeo> But it also defeats a large point of the purpose of Haskell.
20:00:28 <elliott> Oh, importing things?
20:00:38 <Deewiant> elliott: I'm trying to write parse :: Parser BS.ByteString a -> BS.ByteString -> Result s a and am now importing things, yes
20:00:54 <elliott> Deewiant: This will make you happy: https://github.com/ekmett/trifecta/commit/83133201c95d142c6faf5c9e3c6384aea4515c62
20:01:01 <zzo38> Sgeo: Maybe it is. But, it is one reason it should be option; not the default way.
20:01:02 <elliott> Although it doesn't fix the one you were complaining about
20:01:26 <Deewiant> Yeah, it would've made me happy a moment ago
20:01:29 <Deewiant> But not any more
20:01:29 <Taneb> I have done some more work on Salesman
20:01:31 <Deewiant> Although it might still
20:01:38 <Deewiant> Depending on whether I actually need prettyTerm here
20:01:39 <elliott> Wow, I know why disabling fingerprints sped me up
20:01:41 <zzo38> There could also be an option for simple errors, where it does not keep track of information about error but still knows to stop in case of error.
20:01:50 <elliott> Deewiant: Vorpal: -O2 on everything slowed things down
20:01:52 <elliott> Neat.
20:01:54 <elliott> oerjan: too
20:01:56 <zzo38> Either way, it could possibly remove information about errors from the executable file
20:02:18 <elliott> oerjan: Also you didn't answer my question :-P
20:03:08 <Vorpal> elliott, -O2 to what? clang?
20:03:11 <elliott> What, how do I depend on parsec
20:03:13 <elliott> Vorpal: ghc
20:03:16 <Vorpal> ah
20:03:27 <elliott> I guess one of my dependencies depends on parsec
20:03:34 <Vorpal> elliott, maybe you use parsec to "parse" befunge XD
20:03:41 <elliott> No, I dno't
20:03:42 <elliott> don't
20:03:56 <elliott> That's Shiro.Fungespace.mergeByteString
20:04:01 <elliott> The ugliest function in my program
20:04:09 <elliott> Shiro.Fungespace.insertFS is the second-ugliest
20:06:13 <zzo38> Is this a right way of State monad? get :: State s s; get = State $ join (,); put :: s -> State s s; put = State . flip (,);
20:06:33 <elliott> put does not look right.
20:06:51 <zzo38> I know it is the wrong type of the actual State monad.
20:07:26 <zzo38> But this way seems to work as far as I can tell
20:07:36 -!- boily has joined.
20:08:04 <elliott> Well, you haven't told us the definition of State there
20:09:00 <elliott> Deewiant: Wait, -Otwo didn't really slow things down, I think (//percent sign) did
20:09:21 <zzo38> I used newtype State s t = State { runState :: s -> (t, s) };
20:09:22 <Deewiant> When benchmarking, change only one thing at a time :-)
20:09:26 <elliott> How is this program so goddamn fidgety
20:09:32 <elliott> I can't change a single thing without it breaking
20:09:57 <elliott> :t flip (,) 99
20:09:58 <lambdabot> forall a a1. (Num a1) => a -> (a, a1)
20:10:06 <elliott> Hmm, right, it does work
20:10:12 <elliott> The return value is really confusing though
20:10:22 <elliott> Deewiant: Yeah but come oooon
20:10:36 <elliott> Also I'm still waiting for you or oerjan to make that code nicer :-|
20:16:53 <zzo38> It is really confusing? It seem reasonable to me.
20:17:07 <monqy> you're you
20:19:46 <oerjan> elliott: let (aSem, aSems) = (bSem:) <$> splitAt 1 (v ! a) i think, requires Control.Monad.Instances iirc
20:20:21 <Deewiant> let (aSem, aSems) = head &&& (bSem:).tail $ v ! a
20:20:35 <elliott> Those are both less symmetric and therefore gross
20:20:43 <elliott> And one uses arrows
20:20:49 <Deewiant> How less symmetric
20:20:59 <Deewiant> Just define (&&&) locally
20:21:15 <elliott> Actually yours are both broken
20:21:26 <elliott> They do one fewer vector reference
20:21:28 <elliott> So they must be
20:21:39 <elliott> Oh, wait, those are just replacing each line
20:21:42 <elliott> Each line is fine, I mean the whole structure
20:21:47 <Deewiant> let ~(aSem, aSems) = head &&& (bSem:).tail $ v ! a
20:21:48 <Deewiant> ~(bSem, bSems) = head &&& (aSem:).tail $ v ! b
20:21:48 <Deewiant> in v // [(a, aSems), (b, bSems)]
20:21:57 <elliott> Each line is fine, I mean the whole structure
20:21:59 <Deewiant> There's your symmetry
20:22:29 <Deewiant> And I don't think there's much to be done about the whole structure
20:22:36 <oerjan> <elliott> Deewiant: Vorpal: -O2 on everything slowed things down <-- i think the ghc user guide even warns about that possibility.
20:23:14 <zzo38> It seem Control.Monad.State not exposing the data constructor.
20:23:37 <Deewiant> How do I get [(something positiony, error message)] out of trifecta, grr
20:24:08 <elliott> Deewiant: You want to use Trifecta, but don't want the clang-style diagnostics?
20:24:09 <elliott> Neat
20:24:15 <Deewiant> Um
20:24:16 <Deewiant> Where did I say thatt
20:24:24 <elliott> Well, you want to throw away the type of diagnostic
20:24:42 <elliott> http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/Text-Trifecta-Diagnostic.html See Caret/Span
20:24:45 <Deewiant> That can be part of the error message for all I care
20:24:48 <elliott> And all that jazz
20:24:53 <elliott> Deewiant: Then what do you need the position for
20:24:59 <Deewiant> I need to mess with it
20:25:06 <elliott> To do what
20:25:22 <elliott> Please tell me you're not going to re-scan the line so you can adjust the column to account for tabs
20:25:26 <Deewiant> What I'm parsing has been messed with between the user inputting it and trifecta seeing it
20:25:31 <elliott> Gross, why
20:26:03 <oerjan> *elliott: let ([aSem], aSems) = (bSem:) <$> splitAt 1 (v ! a) i think, requires Control.Monad.Instances iirc
20:26:23 <Deewiant> Because it's C and also because I haven't bothered to look into how to fix the fact that my parser requires me consing a newline in front of the input
20:26:40 <elliott> Deewiant: What are you even parsing
20:26:45 <Deewiant> C, I told you
20:27:10 <elliott> Deewiant: Why are the existing C parsers inadequte
20:27:12 <elliott> inadequate
20:27:17 <Deewiant> They're not DeathStation 9000 enough
20:27:28 <elliott> You trying to steal my thunder? :P
20:27:42 <elliott> I think language-c marks all GNU extensions in the AST
20:27:57 <Deewiant> I think it has an identical source and execution character set
20:28:07 <elliott> language-c doesn't execute.
20:28:10 <elliott> It just parses.
20:28:15 <oerjan> <zzo38> It seem Control.Monad.State not exposing the data constructor. <-- that's weird, i thought i'd used it before
20:28:32 <elliott> zzo38: Use "state"
20:28:35 <elliott> :t state
20:28:36 <lambdabot> forall s a. (s -> (a, s)) -> State s a
20:28:37 <Deewiant> I think it doesn't implement the source passes precisely the way the abstract C translator does
20:28:56 <Deewiant> Anyway, conversion to execution character set happens before the conventional "parsing" stage
20:29:00 <zzo38> elliott: OK. But why is it like that?
20:29:01 <elliott> Deewiant: It doesn't do cpp (well it does, but only by invoking cpp), and you're mixing lexing and parsing too
20:29:05 <oerjan> > runState (State $ \s -> (s+s, s-s)) 1
20:29:05 <lambdabot> Not in scope: data constructor `State'
20:29:09 <oerjan> huh
20:29:09 <elliott> zzo38: Because it's StateT
20:29:13 <elliott> oerjan: Like I said, state
20:29:30 <zzo38> O, OK, that's why. Thank you for telling me.
20:29:31 <oerjan> elliott: this must be some new development?
20:29:40 <Deewiant> I'm only mixing lexing and parsing a tiny bit
20:29:42 <elliott> oerjan: mtl two, I think
20:29:47 <Deewiant> In that I gather preprocessing directives as I parse
20:29:49 <elliott> So last October
20:29:50 <Deewiant> Er, lex
20:29:51 <oerjan> :t state
20:29:51 <lambdabot> forall s a. (s -> (a, s)) -> State s a
20:29:52 <elliott> Or was it transformers
20:30:00 <elliott> Oh, mtl two switched to transformers
20:30:09 <Deewiant> And that's only because <foo> could be a header-name or less-than foo greater-than
20:30:14 <elliott> Deewiant: You're mixing lexing and parsing because you're using Parsec/Trifecta/whatever
20:30:14 <Deewiant> And disambiguating that later would be annoying
20:30:16 <elliott> Which do that inherently
20:30:20 <oerjan> elliott: gah if they did that they should have made state a MonadState method :(
20:30:30 <oerjan> one which i recall missing
20:30:34 <Deewiant> elliott: That doesn't matter?
20:30:44 <elliott> Deewiant: Neither does language-c's mixing
20:30:52 <elliott> oerjan: IIRC edwardk has complained that MonadState isn't _just_ state
20:30:56 <elliott> Since you can encode the rest with it
20:30:56 <Deewiant> elliott: It's the principle of the thing
20:31:07 <elliott> Or was it state, get, set, modify with the latter two with defaults in terms of the first
20:31:12 <elliott> Deewiant: I see
20:31:15 <oerjan> elliott: they should have defaults in terms of each other, certainly
20:31:22 <Deewiant> elliott: This doesn't matter from the POV of the abstract C machine, I'm just doing a bit of phase 3 and 4 together
20:31:29 <elliott> Deewiant: You should logread, ais and others had various ideas for DS9King in a way that points out assumptions well
20:31:42 <elliott> For instance the representation of things casted to char pointers
20:31:53 <Deewiant> I'll get to that if/when I get as far as a backend :-p
20:32:23 <elliott> Deewiant: "If"? What the world truly needs is a C parser and typechecker with absolutely nothing else :-P
20:32:41 <elliott> That's the hard part, after all ;-)
20:32:51 <Deewiant> Currently the hard part is lexing
20:33:02 <Deewiant> Diagnostic !(Either String Rendering) !DiagnosticLevel m [Diagnostic m]
20:33:07 <Deewiant> What is the Either and why
20:33:08 <elliott> The hard part of a DS9C
20:33:34 <oerjan> !haskell import Unsafe.Coerce; import Control.Monad.Instances; main = print ((' ':) `fmap` unsafeCoerce "testing" :: (Char, String))
20:33:37 <elliott> Deewiant: http://hackage.haskell.org/packages/archive/trifecta/0.46/doc/html/src/Text-Trifecta-Diagnostic-Prim.html#tellDiagnostic
20:33:39 <EgoBot> ​(
20:33:41 <elliott> See Pretty instance, possibly other
20:33:41 <elliott> s
20:33:45 <oerjan> :(
20:34:10 <elliott> Deewiant: So which C standard are you doing
20:34:17 <Deewiant> Latest
20:34:35 -!- EgoBot has quit (Remote host closed the connection).
20:34:46 -!- EgoBot has joined.
20:34:58 -!- boily has quit (Ping timeout: 260 seconds).
20:35:01 <elliott> Oh no, pushString is one of my bottlenecks
20:35:15 <elliott> I could make it faster, but it'd require OverloadedStrings :-/
20:35:26 <Deewiant> So enable it
20:35:33 <Deewiant> Not like you're portable to non-GHC anyway
20:35:35 <zzo38> The way I defined get and put, I can also define: post :: (s -> s) -> State s s; post f = get >>= put . f;
20:35:41 <elliott> Deewiant: All I depend on is FlexibleInstances and BangPatterns
20:35:47 <elliott> And no GHC. or Unsafe. modules
20:35:51 <elliott> Not even unsafePerformIO
20:35:54 <Deewiant> Oh, darn
20:36:02 <Deewiant> Well, you don't ever /need/ OverloadedStrings
20:36:07 <elliott> Not that anything that isn't GHC can run this, but that's just because they're all crap
20:36:09 <Deewiant> It's just convenience, you can manually convert
20:36:23 <elliott> Deewiant: Weeeeeeeeeeeeeeeeeeeeeeeell... I guess I can try and inline pushString
20:36:25 <elliott> But I'm not doing to write
20:36:34 <zzo38> In Control.State.Monad they have this example: do { n <- get; put (n+1); return n; }
20:36:45 <zzo38> But I do it this way instead: post (1 +)
20:36:56 <elliott> pushString (\stack -> fromIntegral (ord 'z') :- 'y' :- 'x' :- 0 :- stack)
20:37:06 <elliott> fromIntegral and ords omitted for two of those because I got lazy
20:37:12 <zzo38> That is why I prefer to define "put" in this way.
20:38:01 -!- DH____ has joined.
20:39:16 <oerjan> zzo38: post is usually called modify, unless they changed that too.
20:39:26 <oerjan> :t modify
20:39:27 <lambdabot> forall s (m :: * -> *). (MonadState s m) => (s -> s) -> m ()
20:39:32 <elliott> oerjan: He wants -> m s
20:39:33 <elliott> For no apparent reason
20:39:59 <oerjan> well -> m s is admittedly about as intuitive as -> m ()
20:40:02 <elliott> Deewiant: What, inlining pushString slows things down
20:40:15 <elliott> It fucking reverses the string and then builds a simple monadic list of actions out of them
20:40:15 <oerjan> since they are the only reasonable options
20:40:18 <Deewiant> Guess you're not calling it often enough there
20:40:22 <elliott> How can it be slowed down by having to make no assumptions about the string
20:40:23 <elliott> How
20:40:27 <elliott> Erm
20:40:30 <elliott> How can it be sped up by having to make no assumptions about the string
20:40:37 <elliott> And having to go through it twice
20:40:43 -!- Taneb has quit (Read error: Connection reset by peer).
20:40:44 <elliott> oerjan: except he wants it to return the _old_ state
20:40:55 <oerjan> ...oh.
20:41:23 <oerjan> hm i guess post is a better name, then. or perhaps pre?
20:42:01 <zzo38> It is like, postincrement does in C, for example. It return the old state, in C, too.
20:42:23 <oerjan> ah yes.
20:44:12 <oerjan> <elliott> fromIntegral and ords omitted for two of those because I got lazy <-- just define a Integral Char instance >;P
20:44:17 <oerjan> *an
20:44:40 <oerjan> hm wait
20:44:45 <oerjan> that still won't work
20:45:04 <oerjan> needs OverloadedChars :P
20:46:10 <oerjan> you could use OverloadedStrings
20:46:24 -!- Taneb has joined.
20:46:26 <elliott> that's
20:46:29 <elliott> exactly what the topic of discussion was
20:47:05 <oerjan> how logical.
20:47:55 <oerjan> apparently my eyes glazed over everything except the actual haskell code :P
20:52:16 <zzo38> Maybe I will make the Haskell preprocessor program you have overloaded everything.
20:52:30 <elliott> Deewiant: What. Removing my check for \0 in pushString makes things slower.
20:52:36 <elliott> Just
20:52:36 <elliott> What
20:52:40 <elliott> Noticably slower too
20:52:43 <elliott> Like almost half a second slower
20:52:45 -!- KingOfKarlsruhe has joined.
20:53:01 <elliott> Ugh, not almost half a second
20:53:07 <elliott> It's that fucking //percent sign again
20:53:11 <Deewiant> Are you pushing huge strings now instead of stopping at the null like you should? ;-)
20:53:36 <elliott> Deewiant: I don't "stop at the null", I error out at the null.
20:53:45 <oerjan> // is not a percent sign. trust me on this.
20:53:47 <elliott> Haskell Strings can contain \0s; 0gnirtses can't.
20:53:54 <Deewiant> error "x" is probably more expensive than something else
20:54:03 <oerjan> elliott: increased strictness perhaps?
20:54:04 <elliott> Deewiant: It's /never reached/
20:54:13 -!- kmc has joined.
20:54:17 <elliott> oerjan: push is strict, so it isn't that
20:54:18 <Deewiant> It's still created
20:54:22 <elliott> Deewiant: No?
20:54:27 <elliott> where pushChars [] = return ()
20:54:27 <elliott> pushChars ('\0':_) =
20:54:27 <elliott> error $ "pushStringAs0Gnirts " ++ show s ++ ": string contains NUL byte"
20:54:27 <elliott> pushChars (c:s') = do
20:54:27 <elliott> push . fromIntegral . ord $ c
20:54:28 <elliott> pushChars s'
20:54:31 <elliott> I literally commented out the \0 clause.
20:54:37 <zzo38> You don't need OverloadedStrings but it should help more in my opinion, if you can program the overloading at compile-time, when you have access to the source file when doing the program that is for overloading
20:54:52 <Deewiant> Then the c isn't strict, maybe?
20:55:15 <elliott> Deewiant: Like I said, push is strict
20:55:18 <elliott> Very strict
20:55:32 <Deewiant> So?
20:55:33 <oerjan> elliott: what happens if you replace the $ c by $! c ?
20:55:38 <Deewiant> Does pushChars realize that?
20:55:53 <elliott> push :: Value -> Shiro ()
20:55:54 <elliott> push x = modifyStack (stackCons x)
20:55:54 <elliott> stackCons :: Value -> Stack -> Stack
20:55:54 <elliott> stackCons x (Stack n (x' :- xs)) = Stack (n+1) (x :- x' :- xs)
20:55:54 <elliott> infixr 5 :-
20:55:54 <elliott> data StackElems = (:-) {-# UNPACK #-} !Value StackElems deriving (Show)
20:55:56 <elliott> data Stack = Stack {-# UNPACK #-} !Value !StackElems deriving (Show)
20:56:16 <elliott> oerjan: Let's find out
20:56:40 <oerjan> elliott: or better, use (!c:s') in the pattern
20:56:52 <elliott> oerjan: That would make me use more extensions :-(
20:56:57 <elliott> Currently I use each extension in only one file :P
20:57:11 <elliott> oerjan: Gah, yes, $! reverses the slowdown
20:57:12 <oerjan> sigh, c `seq` do then
20:57:13 <Deewiant> pushChars c : s' | seq c otherwise = do
20:57:17 <elliott> I'll keep it but put the \0 back
20:57:22 <elliott> As in, the \0 clause
20:57:25 <Deewiant> elliott: Toldja so
20:57:32 <elliott> Deewiant: It's unnatural :-(
20:57:43 <elliott> Deewiant: How many IPs does Mycology create, roughly
20:57:48 <Deewiant> ccbi -s
20:57:48 <elliott> rotate :: ([a],[a]) -> ([a],[a])
20:57:48 <elliott> rotate ([ip], r) = (reverse r ++ [ip], [])
20:57:48 <elliott> rotate (ip:xs, r) = (xs, ip:r)
20:57:48 <elliott> rotate _ = error "rotate: no IPs"
20:57:48 <elliott> remove :: ([a],[a]) -> ([a],[a])
20:57:49 <elliott> remove ([_], r) = (reverse r, [])
20:57:51 <elliott> remove (_:xs, r) = (xs, r)
20:57:53 <elliott> remove _ = error "remove: no IPs"
20:57:55 <elliott> These look pretty slow
20:57:57 <elliott> Deewiant: CCBI this, CCBI that; sheesh
20:58:07 <elliott> How do I disable TURT
20:58:10 <elliott> -F -turt?
20:58:12 <elliott> -f -TURT
20:58:12 <elliott> I forget
20:58:16 <Deewiant> As do I
20:58:16 <elliott> Yeah, -f -TURT
20:58:22 <Vorpal> elliott, iirc at most 3 threads at the same time, but over an entire run, much more
20:58:25 <elliott> (It creates a file which is annoying)
20:58:35 <elliott> elliott@katia:~/Code/shiro$ ~/ccbi-2.1/ccbi -s -f -TURT rsc/mycology/mycology.b98
20:58:35 <elliott> CCBI :: unexpected argument 'R'. Use '--help' for help.
20:58:35 <elliott> CCBI :: unexpected argument 'T'. Use '--help' for help.
20:58:35 <elliott> CCBI :: unexpected argument 'U'. Use '--help' for help.
20:58:35 <elliott> CCBI :: argument 'fingerprints' expects 1 parameter(s), but has only 0.
20:58:37 <elliott> Deewiant: Bug report.
20:58:45 <elliott> Forked: 6 IPs
20:58:46 <elliott> Stopped: 7 IPs
20:58:46 <elliott> Had: 2 IPs live at maximum
20:58:46 <elliott> Was dormant: 1 IP
20:58:48 <elliott> Vorpal: Much more being "six"
20:59:00 <elliott> OK, so my IP list code is probably not any kind of bottleneck.
20:59:07 <Vorpal> elliott, huh, thought it was like 10
20:59:19 <elliott> That's much more? :-P
20:59:32 <Vorpal> elliott, yes
20:59:38 <Vorpal> not like "much" is well defined anyway
20:59:39 <Deewiant> elliott: -f-TURT
20:59:49 <Deewiant> elliott: -f +all,-TURT (IIRC)
20:59:56 <elliott> Deewiant: Lame
21:00:00 <elliott> That's not getopt standard (TM)
21:00:03 <elliott> Well, I don't think
21:00:11 <Deewiant> It's not my argument parser
21:00:22 <elliott> It should be
21:00:30 <Deewiant> It won't be
21:00:45 <elliott> Admittedly Shiro uses someone else's argument parser
21:00:48 <elliott> But it has exactly two argument
21:00:49 <elliott> s
21:01:02 <elliott> currentIP Shiro.Monad 1.8 0.4
21:01:02 <elliott> Maybe my iplist code /is/ a bottleneck
21:01:24 <elliott> f (x:xs) = xs ++ [x]
21:01:30 <elliott> oerjan: That's O(1) in practice, right?
21:01:36 <elliott> If I only ever look at the head, or do f
21:01:41 <elliott> That's literally the only options I ever do on the list
21:01:47 <elliott> Oh, wait
21:01:51 <elliott> I also take the tail
21:03:13 <elliott> Thanks oerjan
21:03:26 <oerjan> i dunno
21:03:35 <elliott> Bah
21:04:01 <elliott> Hey Deewiant, that's O(one) in practice, right
21:04:08 <oerjan> maybe quadratic in the number of f's applied
21:04:20 <elliott> oerjan: I always access the head before f
21:04:29 <elliott> As in, my usage looks like
21:04:41 <elliott> head, f, head, f, head, f, head, tail, head, f, ...
21:05:31 <oerjan> hm i may still suspect quadratic.
21:05:42 <elliott> Hmm, I'm surprised my current code isn't broken; Deewiant: After quitting an IP, I still go to the next IP
21:05:49 <elliott> As in, I skip the IP directly after the quit one's turn
21:05:52 <elliott> Do you check for that?
21:06:00 <oerjan> actual profiling might discover the truth :P
21:06:01 <elliott> If so, I guess Mycology understands my code better than I do
21:06:03 <Deewiant> Probably not
21:06:12 <Deewiant> I only check concurrent code with two IPs, remember
21:06:15 <elliott> >_<
21:06:19 <Deewiant> So if you skip a turn it's missed
21:06:31 <Deewiant> When you implement TRDS it'll notice, don't worry :-)
21:06:54 <elliott> I'm trying to optimise before that
21:07:05 <elliott> ?pl pop >>= \a -> push a >> push a
21:07:05 <lambdabot> liftM2 (>>) push push =<< pop
21:07:22 <elliott> <Deewiant> pop >>= join (liftM2 (>>)) push
21:07:40 <Deewiant> Right
21:07:54 <oerjan> elliott: because the linear cost of applying xs ++ [x] is spread across the entire part before ++, so head will only affect it a tiny bit, i think
21:08:31 <oerjan> while each f followed by a head will apply the cost of all the previous f's at that point
21:08:31 <elliott> oerjan: Right
21:08:46 <elliott> oerjan: That's annoying :/
21:09:16 <elliott> oerjan: I basically have a list of N elements, and a pointer into this list that I increment; upon reaching the end, it resets to the start
21:09:22 <elliott> And sometimes I remove an element from the list
21:09:30 <elliott> The question is how to do that without something ugly like a vector :P
21:09:46 <elliott> Last time you got me to use zippers, but that involves reversing on the reset-to-start case
21:09:46 <oerjan> zipper?
21:09:49 <elliott> Last time you got me to use zippers, but that involves reversing on the reset-to-start case
21:09:53 <elliott> rotate :: ([a],[a]) -> ([a],[a])
21:09:53 <elliott> rotate ([ip], r) = (reverse r ++ [ip], [])
21:09:53 <elliott> rotate (ip:xs, r) = (xs, ip:r)
21:09:53 <elliott> rotate _ = error "rotate: no IPs"
21:09:53 <elliott> remove :: ([a],[a]) -> ([a],[a])
21:09:54 <elliott> remove ([_], r) = (reverse r, [])
21:09:56 <elliott> remove (_:xs, r) = (xs, r)
21:09:56 <oerjan> yep
21:09:58 <elliott> remove _ = error "remove: no IPs"
21:10:05 <elliott> Which is ugly and non-constant-time
21:10:15 <oerjan> ...still better than quadratic :P
21:10:38 <elliott> >:(
21:10:46 <elliott> I guess I'll try sequencing the list
21:11:36 <elliott> rotate :: ([a],[a]) -> ([a],[a])
21:11:36 <elliott> rotate ([ip], r) = length xs' `seq` (xs', []) where xs' = reverse r ++ [ip]
21:11:36 <elliott> rotate (ip:xs, r) = (xs, ip:r)
21:11:36 <elliott> rotate _ = error "rotate: no IPs"
21:11:38 <elliott> Maybe this'll do better
21:12:11 <elliott> Gah, reverse on Seq is O(one)
21:12:22 <elliott> erm
21:12:23 <elliott> O(n)
21:12:29 <elliott> I thought it might be able to do some fancy "just flip a bit" thing, since it has O(one) accessing from the end
21:12:48 <oerjan> elliott: you can fake that with wrapping around it
21:12:54 <elliott> Hmm, that seq doesn't seem to help
21:13:02 <elliott> At least not noticeably
21:13:07 <elliott> oerjan: Yeah, just wondering whether it's worth it
21:13:09 <elliott> I'll give it a try
21:13:20 <oerjan> but if you use Seq, why use reverse
21:13:48 <oerjan> just append things, which is supposed to be cheap
21:14:05 <elliott> oerjan: um because I'd still use a zipper?
21:14:10 <elliott> oh hmm I see
21:14:17 <oerjan> elliott: if you use Seq there's no point in a zipper
21:14:22 <elliott> yes, that might work, thanks :)
21:14:27 <elliott> I swear to god I've tried Seq for this before...
21:14:41 <oerjan> i may even have been the one suggesting it ;P
21:15:55 <oerjan> i'm sure queues _is_ one of the suggested use cases for it
21:17:08 <elliott> yeah I think I might have tried Seq on your suggestion?
21:17:18 <elliott> maybe I decided this was simpler
21:17:18 <elliott> dunno
21:17:20 <elliott> I must have been an idiot
21:17:25 <oerjan> it is conceivable that you dropped it because zippers were more efficient in total?
21:17:42 <oerjan> after all the reverse only applies each time you have traversed the list completely
21:17:54 <elliott> oerjan: I definitely wasn't thinking about speed at that point :-)
21:18:26 <oerjan> i suspect zippers are more efficient but Seq's may be more "real-time"
21:18:45 <elliott> Deewiant: Does Fungicide test tons of concurrent IPs
21:18:50 <oerjan> that is, less max waiting
21:19:02 <Deewiant> elliott: Yes
21:19:05 <elliott> Deewiant: How many
21:19:27 <Deewiant> http://iki.fi/matti.niemenmaa/befunge/fungicide-rankings/fork.b98.html
21:19:53 <elliott> oerjan: Seq should be more efficient for 131072 items, right?
21:20:24 <oerjan> elliott: only at the point when you do the reverse for a zipper
21:20:34 <elliott> oerjan: I mean in total :-P
21:20:36 <elliott> But hmm
21:21:05 <oerjan> a zipper is a _much_ simpler data structure, so i think it's more efficient in total
21:22:33 <oerjan> mind you this is a hunch, i'm not known for actually optimizing my own programs ;P
21:22:44 <elliott> Deewiant: So how many instructions does each IP execute
21:22:49 <elliott> I mean, I need to reverse every N instructions, where N = number of IPs
21:23:01 <elliott> And reversing a list of 131072 items won't be fast
21:23:34 <Deewiant> I think they all just z until they all @ at once
21:23:43 <Deewiant> So [1..131072]
21:23:56 <oerjan> elliott: indeed. but amalgamawordineverremembered, it's spread out over all the previous 131072 steps and becomes O(1) per step
21:24:14 <Deewiant> amortized
21:24:19 <oerjan> right
21:24:26 <elliott> Deewiant: Heh
21:24:40 <elliott> oerjan: right
21:24:58 <oerjan> and each step is O(1) anyhow, so there's only a constant multiple for it
21:25:02 <elliott> Well, let's see what it does to my Mycology performance
21:25:23 <elliott> oerjan: executing an instruction is _not_ O(1)
21:25:45 <elliott> well hmm, I don't think
21:25:48 <oerjan> elliott: in that case the reverse should be even less significant
21:25:53 <elliott> oerjan: well no it is in practice
21:26:08 <elliott> but there are edge-cases, like k can do any finite number of executions of a single instruction
21:26:22 <oerjan> ok
21:27:45 <elliott> oerjan: Holy crap Seqs are slower
21:27:49 <Taneb> Had an algorithm test in further maths
21:27:52 <elliott> Like, it's been running for several seconds already
21:28:00 <oerjan> elliott: was 'fraid so
21:28:01 <elliott> Oh hmm
21:28:04 <elliott> Going to test concurrent execution with 2 IPs.
21:28:04 <elliott> Assuming that instructions without any particular concurrency-related behaviour, such as ^>v<#, take one tick.
21:28:04 <elliott> Will continue to produce textual output, so strings must work correctly where concurrency is concerned: "a b" should take 5 ticks, 'a should take 1.
21:28:04 <elliott> [LITERAL HANG]
21:28:06 <elliott> OK, so it's just broken
21:28:18 <elliott> But it was definitely slower before anyway
21:28:20 <Taneb> Compared to even the stuff that I understnad that bounces back and forth in this channel, it was first school stuff
21:29:29 <Taneb> 20 marks for doing a thingy with bubblesort
21:29:37 <Taneb> Debug trace
21:29:37 <Taneb> Shuttlesort, rather
21:29:39 <elliott> Bubblesort, the best sort.
21:29:45 <elliott> Debug traces are algorithms?
21:29:54 <oerjan> it's bubbly!
21:33:16 <oerjan> <Taneb> Everything starts going wrong when the comic is put in the bin
21:33:18 <oerjan> aha
21:33:53 <elliott> oerjan: Five more comics of IWC for you
21:33:59 * elliott continues hobbying.
21:34:07 <oerjan> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaa
21:34:18 <elliott> Ah, the sweet sound of horror.
21:34:30 <elliott> "I kind of assumed that if Choking was to be made permanently Choking, Fireballs would be made permanently Fireballs again. This seems so final, though; I hope this doesn't mean the story is coming to an end."
21:34:35 <elliott> You know the story is ending when deaths start getting demoted.
21:34:51 <oerjan> whatever dmm intends, he is certainly keeping up the suspense by seemingly wrapping up things
21:35:16 <elliott> oerjan: My prediction is: a giant fireball and everything resets. That would be new!
21:35:28 <oerjan> u think
21:35:38 <elliott> u mad?
21:35:42 <monqy> :(
21:35:45 <elliott> In this analogy, u mad because IWC is ending.
21:36:02 <oerjan> u thant
21:36:07 <elliott> wat
21:36:54 <oerjan> angkor
21:37:00 <elliott> no
21:38:12 <oerjan> dr.
21:38:25 <elliott> ok
21:38:32 <oerjan> o
21:38:40 <elliott> help
21:38:45 <oerjan> u mad?
21:39:07 <Vorpal> oerjan, is it confirmed that iwc is ending?
21:39:21 <oerjan> Vorpal: not last i checked :P
21:39:25 <Vorpal> good
21:39:42 <elliott> thank god it isn't /confirmed/, only obvious :P
21:40:02 <Vorpal> oerjan, I suspect he will do one more than what everyone thinks he is going to stop at.
21:40:57 <Taneb> But some people think he is going to do that!
21:41:11 <Vorpal> Taneb, well, the majority I meant
21:41:26 <oerjan> the majority hasn't said anything, on the forum at least
21:41:33 <Vorpal> right
21:41:40 <elliott> they're trying to avoid giving him ideas
21:41:44 <Vorpal> oerjan, he should run a poll XD
21:42:17 <oerjan> although there was one person who misremembered the number as 3150 and posted a relief post that it hadn't stopped then
21:42:28 <elliott> i just read that lol
21:43:05 <Vorpal> oerjan, what is the actual number now again?
21:43:10 -!- Wamanuz has quit (Remote host closed the connection).
21:43:50 <oerjan> 3160
21:43:57 <Vorpal> ah
21:44:08 <Sgeo> number of what?/
21:44:17 <Vorpal> The Number
21:44:45 <elliott> number of green people in world
21:45:23 <oerjan> Sgeo: dmm has several times mentioned that he wanted to reach the number of calvin & hobbes comics, 3160.
21:45:36 <oerjan> and now iwc is at #3155
21:46:27 <oerjan> at the same time as several of the iwc themes look eerily like they're in a "wrapping up" stage
21:46:54 <oerjan> the fantasy group even finished their quest!
21:47:17 <elliott> What was their quest again? My knowledge of IWC is so patchy.
21:47:18 <Sgeo> Is it not a regular occurance for IWC to seem to be ending?
21:47:26 <oerjan> yes, that's true
21:47:35 <oerjan> but still, some of us are worried.
21:47:50 <elliott> oerjan: five comics seems a bit short to wrap up everything, from the last ten or so I read
21:48:10 <oerjan> elliott: perhaps.
21:48:21 <elliott> oerjan: maybe it'll end on 3163 :D
21:48:25 <elliott> just to catch everyone out
21:48:29 <oerjan> eek
21:48:34 <Taneb> I reckon he's going to go into Supers and Espionage again
21:48:38 <Taneb> After 3160
21:49:16 <oerjan> supers does require him to get hold of the illustrator...
21:49:27 <elliott> oh no, getting a hold of an illustrator
21:49:31 <elliott> a well-known impossibility
21:49:44 <elliott> Harry Potter is also disconnected, isn't it?
21:50:02 <oerjan> elliott: um _the_ illustrator, who obviously cannot be much interested since he hasn't made any for years...
21:50:22 <elliott> oerjan: "can I have another bunch of comics since I'm ending the strip you drew a bunch of comics for"
21:50:28 <oerjan> well harry potter may or may not be happening entirely within will shakespeare's mind...
21:50:34 <elliott> doesn't sound _that_ hard to achieve :P
21:51:02 <oerjan> well ok, maybe one or so might be possible
21:52:21 -!- Wamanuz has joined.
21:54:06 <oerjan> <elliott> Aren't Deltas a monoid
21:55:19 <oerjan> Delta = data type for representing a generalization of character width including tabs of arbitrary column settings?
21:55:40 <Deewiant> Delta = data type representing a position in a file
21:55:42 <Deewiant> I /think/
21:55:46 <Deewiant> I still don't get half of it
21:55:47 <oerjan> oh.
21:56:01 <oerjan> did anyone give an actual definition?
21:56:07 <Deewiant> (Where "it" = position/source representation in Trifecta)
21:56:18 <oerjan> oh hm.
21:57:06 <Deewiant> data Delta
21:57:07 <Deewiant> Columns !Int64 !Int64
21:57:07 <Deewiant> Tab !Int64 !Int64 !Int64
21:57:07 <Deewiant> Lines !Int64 !Int64 !Int64 !Int64
21:57:08 <Deewiant> Directed !ByteString !Int64 !Int64 !Int64 !Int64
21:57:36 <oerjan> instance Monoid Delta where mempty = Columns 0 0 mappend = (<>)
21:57:44 <oerjan> found that
21:58:00 <oerjan> http://hackage.haskell.org/packages/archive/trifecta/0.36.3/doc/html/src/Text-Trifecta-Rope-Delta.html
21:58:15 <Deewiant> Yes, it's a Monoid, we knew that :-P
21:58:30 <oerjan> i thought you were asking
21:58:50 <Deewiant> 2011-09-16 21:58:58 ( elliott) Aren't Deltas a monoid
21:58:50 <Deewiant> 2011-09-16 21:59:07 ( elliott) In which case you just need to replace wherever mempty is called
21:58:53 <Deewiant> 2011-09-16 21:59:08 ( Deewiant) Yes
21:59:03 <Deewiant> That "Yes" was to the former
21:59:37 <oerjan> ok
22:00:17 -!- Taneb has quit (Ping timeout: 276 seconds).
22:01:51 <oerjan> <Deewiant> It's a cofree comonad
22:02:08 <oerjan> i keep wanting to read that as coffee comonad
22:02:33 <elliott> fromList :: [Word8] -> ByteSet
22:02:33 <Deewiant> I actually read that as coffee comonad until I noticed that I said it
22:02:34 <elliott> fromList s0 = ByteSet $ I.unsafeCreate 32 $ \t -> do
22:02:34 <elliott> _ <- I.memset t 0 32
22:02:34 <elliott> let go [] = return ()
22:02:34 <elliott> go (c:cs) = do
22:02:34 <elliott> prev <- peekByteOff t byte :: IO Word8
22:02:36 <elliott> pokeByteOff t byte (prev .|. bit)
22:02:38 <elliott> go cs
22:02:40 <elliott> where I byte bit = index (fromIntegral c)
22:02:42 <elliott> go s0
22:02:47 <elliott> Neat.
22:03:36 <Deewiant> mapM_ something-simpler s0
22:08:01 -!- elliott has quit (Ping timeout: 260 seconds).
22:08:46 -!- Patashu has joined.
22:12:51 -!- derdon has quit (Remote host closed the connection).
22:14:52 -!- cheater has joined.
22:20:27 -!- cheater has quit (Remote host closed the connection).
22:20:51 -!- cheater99 has joined.
22:40:11 -!- DH____ has quit (Ping timeout: 260 seconds).
22:44:13 -!- cheater99 has quit (Quit: Ex-Chat).
22:44:49 -!- DH____ has joined.
22:46:39 -!- cheater has joined.
23:01:49 <CakeProphet> hmmm so I'm thinking about buying a server.
23:01:58 <CakeProphet> getting my own place with a static IP
23:07:11 <CakeProphet> I wonder how much a decent server will cost...
23:07:14 <CakeProphet> and decent broadband.
23:07:23 -!- Zuu has joined.
23:11:39 -!- nys has joined.
23:15:42 <CakeProphet> wow comcast is fucking expensive.
23:15:54 <CakeProphet> 50 mbps for $100
23:15:55 <CakeProphet> a month
23:16:10 <CakeProphet> that's their fastest speed. the next lowest is 16 mbps
23:18:50 <monqy> so why do you want this
23:18:51 <monqy> server
23:19:00 <monqy> _secrets?????????????????_
23:19:04 <CakeProphet> business website, business....server.
23:19:09 <monqy> business
23:19:11 <CakeProphet> for... business
23:19:37 <CakeProphet> also it will basically just be an awesome desktop...
23:19:45 <CakeProphet> so I can play games. :P
23:19:52 <monqy> biz tld please say yes
23:19:54 <CakeProphet> like DF, which is apparently too intense for my laptop.
23:20:09 <CakeProphet> monqy: uh, yes.
23:20:14 <monqy> yesssss
23:20:14 <CakeProphet> er.
23:20:15 <CakeProphet> no
23:20:18 <monqy> noo ;_;
23:20:21 <CakeProphet> you mean like... .biz?
23:20:23 <CakeProphet> no
23:20:26 <monqy> yes .biz
23:20:34 <CakeProphet> no that's a dumb top-level domain.
23:20:44 <CakeProphet> no one uses that.
23:20:46 <CakeProphet> fuck ICANN
23:20:47 <monqy> all biznes sites need it
23:21:05 <CakeProphet> .com is where it's at.
23:21:29 <CakeProphet> actually I really don't have too many uses for a server
23:21:30 <monqy> cakes cool community club
23:21:33 <CakeProphet> I should probably think of those.
23:21:40 <monqy> business, dwarf fortress
23:21:43 <monqy> "good enough"
23:22:09 <CakeProphet> well if I ever go into profitshare I could offering hosting of sites.
23:22:31 <monqy> will there be anything special to your hosting i like special
23:22:49 <CakeProphet> uh, included server maintenance / sysadmin shit.
23:23:14 <CakeProphet> that's a thing right?
23:23:20 <CakeProphet> "included sysadmin shit"
23:23:22 <monqy> I think so
23:23:42 <monqy> but what does it do
23:23:50 <CakeProphet> so basically someone hires me to set up their stupid blog/CMS nonsense
23:24:02 <CakeProphet> and then I maintain it and host it on my server for a monthly fee.
23:24:21 <CakeProphet> so their feeble brains don't have to worry about it.
23:25:00 <monqy> good luck hosting popular blogs with your server box
23:25:12 <CakeProphet> doesn't need to be popular
23:25:22 <monqy> if they're popular you're dead
23:25:23 <CakeProphet> I just need to get paid.
23:25:59 <CakeProphet> oh look kallisti.com is not taken.
23:26:10 <CakeProphet> no one take it. it's mine.
23:26:13 <monqy> ok
23:26:25 <CakeProphet> oh wait
23:26:30 <CakeProphet> www.kallisti.com is taken.
23:26:38 <CakeProphet> "This page intentional left blank."
23:26:43 <CakeProphet> NAME SQUATTING ASSHOLE.
23:26:48 <CakeProphet> *intentionally
23:27:38 <zzo38> Checking corresponding IP address of domain names does not seem the way to check if it is taken; use WHOIS instead.
23:27:58 <monqy> kallisti.biz
23:28:37 <monqy> hm what's in the newest batch of tlds
23:28:38 -!- FireFly has quit (Quit: FireFly).
23:29:16 <CakeProphet> why does whois read like an advertisement help
23:29:35 <zzo38> Some of them do. I don't know why.
23:29:51 <monqy> this tld list is crazy
23:29:55 <CakeProphet> NOTE: FAILURE TO LOCATE A RECORD IN THE WHOIS DATABASE IS NOT INDICATIVE
23:29:55 <CakeProphet> OF THE AVAILABILITY OF A DOMAIN NAME.
23:30:01 <monqy> wtf sort of tld is XN--CLCHC0EA0B2G2A9GCD
23:30:14 <monqy> I see xxx made it in there
23:30:28 <monqy> can't wait for someone to use .museum
23:30:59 <CakeProphet> kallisti.biz has been claimed by godaddy.
23:31:04 <monqy> .cat good tld
23:31:09 <monqy> .coop
23:31:16 <CakeProphet> chicken.coop
23:31:29 <CakeProphet> cool.cat
23:31:31 <monqy> .info .jobs .name .mobi .travel
23:31:50 <monqy> arpa asia aero
23:31:52 <CakeProphet> kallisti.name
23:31:54 <CakeProphet> doesn't have the same ring
23:32:07 <zzo38> CakeProphet: Well, there are many ways to check, you could probably use all of them. One is a DNS lookup, one is WHOIS. I don't know what else would help.
23:32:34 <CakeProphet> zzo38: "typing the host name into google Chrome" counts as a DNS lookup, yes?
23:32:41 <monqy> ooh here's a good one
23:32:44 <zzo38> CakeProphet: Yes
23:32:45 <monqy> kallisti.pro
23:32:48 <CakeProphet> that's what I did originally, to discover that "this page is intentionally left blank"
23:32:51 <CakeProphet> monqy: ha, nice.
23:32:57 <CakeProphet> Kallisti Professional
23:33:28 <CakeProphet> no whois match
23:33:38 <zzo38> You can also use country codes
23:33:51 <CakeProphet> I think .pro is the way to go
23:33:52 <CakeProphet> bahahahaha
23:33:53 <monqy> kallisti.xxx
23:34:06 <CakeProphet> yeah so I can be blacklisted in China. sounds good.
23:34:35 <CakeProphet> http://www.felarya.com/wiki/index.php?title=Kallisti
23:34:48 <CakeProphet> Once an ordinary succubus, Kallisti spent several millenia gathering power, influence, and souls and became a goddess widely worshiped on several worlds. She is beautiful, sensual and is known both for her terrible brutality on the battlefield, and for her encyclopedic knowledge of the ways of pleasure.
23:35:10 <CakeProphet> based on the wiki logo I'm guessing it's some kind of vorephilia roleplay community?
23:35:21 <monqy> good for .xxx
23:35:47 <CakeProphet> it was one of the listing that showed up from one of those auto-generated ISP pages
23:35:51 <CakeProphet> when I typed in kallisti.pro
23:36:04 <monqy> i hate those things
23:36:20 <oerjan> <monqy> wtf sort of tld is XN--CLCHC0EA0B2G2A9GCD <-- hm is that the unicode encoding format?
23:36:22 <monqy> also when isp gives false dns results
23:36:46 <monqy> oerjan: perhaps; I was looking at http://data.iana.org/TLD/tlds-alpha-by-domain.txt
23:36:53 <CakeProphet> monqy: yeah normally I ignore them but when I saw that snippet I had to click...
23:37:50 <Gregor> oerjan: Punycode
23:37:59 <Gregor> (Is the name of it)
23:38:02 <oerjan> Gregor: rings a bell
23:38:21 <Gregor> Its a format for encoding short Unicode strings as ASCII containing only letters and dashes.
23:38:33 <Gregor> That restriction being for the obvious reason of domain names :)
23:38:48 <Gregor> It's the standard for Unicode domains.
23:39:26 <CakeProphet> domain names sure are stupid.
23:39:56 <Gregor> So are confectionery prophecies!
23:40:47 <oerjan> "singapore" in Tamil script, it seems
23:40:56 <CakeProphet> !cpick steal_cash steal_furniture steal_jewelry leave_through_window hide_body
23:40:59 * oerjan didn't know singapore used tamil script
23:41:01 <EgoBot> steal_cash steal_furniture steal_jewelry
23:41:12 <Gregor> oerjan: I strongly suspect that they do not :P
23:42:06 <oerjan> சிங்கப்பூர்
23:42:10 <CakeProphet> !cpick smoke_hookah do_homework party
23:42:16 <EgoBot> do_homework
23:42:19 <CakeProphet> ...
23:42:27 <CakeProphet> WRONG
23:51:10 -!- Tjr has joined.
23:53:31 -!- elliott has joined.
23:54:02 <elliott> 23:01:49: <CakeProphet> hmmm so I'm thinking about buying a server.
23:54:02 <elliott> 23:01:58: <CakeProphet> getting my own place with a static IP
23:54:02 <elliott> 23:07:11: <CakeProphet> I wonder how much a decent server will cost...
23:54:02 <elliott> 23:07:14: <CakeProphet> and decent broadband.
23:54:07 <elliott> CakeProphet: Dude, just get a VPS.
23:55:20 <monqy> can a vps do df.....................
23:55:57 <zzo38> I have been able to run a server with dynamic IP address; that is what domain names help with.
23:56:41 <Gregor> Dwarf Fortress?
23:56:50 <elliott> 23:28:37: <monqy> hm what's in the newest batch of tlds
23:56:50 <elliott> one is .xxx
23:56:54 <Gregor> Surely a 1996 PC running DOS 6 can do Dwarf Fortress :P
23:56:57 <elliott> Deewiant: Did it work in the end
23:57:00 <Gregor> Oh, I haven't bought a .xxx domain!
23:57:01 <elliott> Gregor: ...you're joking, right?
23:57:05 <elliott> DF is very CPU-intensive.
23:57:10 <elliott> It's /famous/ for being CPU-intensive.
23:57:19 <Gregor> elliott: I assumed that it wasn't because whyTF would it be :P
23:57:30 <Gregor> Welllll
23:57:37 -!- itidus20 has joined.
23:57:37 <elliott> Gregor: Its liquid physics are very complex, as are its AIs
23:57:37 <Gregor> I guess it maintains a RIDICULOUS amount of state about all the agents.
23:57:44 <elliott> And you have like a hundred dorfs+ at a time.
23:57:45 <Gregor> OK, fair 'nuff.
23:58:32 <elliott> Gregor: It's like "Minecraft looks like crap, why does it eat all my RAM" :-P
23:58:48 <elliott> 23:31:09: <monqy> .coop
23:58:48 <elliott> .coop is ancient, monqy
23:59:00 <elliott> Well, 2001
23:59:15 <monqy> that doesn't make it not dumb
23:59:21 <elliott> Why is it dumb
23:59:23 <itidus20> wow a new log day begins in like 1 minute
23:59:31 <elliott> It's a very reasonable TLD
23:59:56 <Gregor> And chicken.coop is actually a co-op! D-8
←2011-09-15 2011-09-16 2011-09-17→ ↑2011 ↑all