←2012-01-21 2012-01-22 2012-01-23→ ↑2012 ↑all
00:15:12 -!- itidus21 has left ("Leaving").
00:20:34 -!- Frooxius has quit (Quit: ChatZilla 0.9.88-rdmsoft [XULRunner]).
00:20:55 -!- Frooxius has joined.
00:28:16 <zzo38> Some games have Vancian casting. So now, make up the game with Vatican casting.
00:30:44 -!- Phantom_Hoover has quit (Quit: Leaving).
00:40:36 -!- ais523 has quit (Remote host closed the connection).
00:43:16 -!- DCliche has joined.
00:47:16 -!- Klisz has quit (Ping timeout: 276 seconds).
00:56:03 <kallisti> > ((+1) &&& (*2)) 4
00:56:04 <lambdabot> (5,8)
00:57:10 -!- rodgort has quit (Quit: ERC Version 5.3 (IRC client for Emacs)).
00:57:28 -!- rodgort has joined.
01:00:44 <tswett> "An important limitation upon programming is that the machine must adhere to a prescribed linear course of operation. It cannot at any point choose between two subsequent programs on the basis of results already obtained."
01:00:49 <tswett> I guess programming has changed since 1947.
01:01:02 <kallisti> lol
01:01:25 <kallisti> a bit
01:13:54 <pikhq> I guess if was invented later.
01:19:31 <kallisti> :t unfoldr
01:19:33 <lambdabot> forall b a. (b -> Maybe (a, b)) -> b -> [a]
01:19:40 <kallisti> hm
01:19:58 <kallisti> ah
01:30:22 <zzo38> A Black Sheep is still a Sheep.
01:33:10 <Sgeo> http://sigcis.org/pipermail/members/2009-February/191226.html
01:33:35 <Sgeo> I think that ... the discovery of "if"?
01:35:23 <kallisti> @undo do { x <- m; y <- m2; f x y }
01:35:23 <lambdabot> m >>= \ x -> m2 >>= \ y -> f x y
01:35:41 <kallisti> erm
01:36:00 <kallisti> @@ @pl @do { x <- m; y <- m2; f x y }
01:36:00 <lambdabot> Parse error at "{" (column 1)
01:36:22 <kallisti> @. pl do { x <- m; y <- m2; f x y }
01:36:23 <lambdabot> Parse error at "{" (column 1)
01:36:25 <kallisti> erm
01:36:27 <kallisti> @help @@
01:36:28 <lambdabot> help <command>. Ask for help for <command>. Try 'list' for all commands
01:36:37 -!- coppro has changed nick to coppro_.
01:36:38 <kallisti> @help @
01:36:38 <lambdabot> @ [args].
01:36:38 <lambdabot> @ executes plugin invocations in its arguments, parentheses can be used.
01:36:38 <lambdabot> The commands are right associative.
01:36:38 <lambdabot> For example: @ @pl @undo code
01:36:38 <lambdabot> is the same as: @ (@pl (@undo code))
01:36:57 -!- coppro_ has changed nick to coppro.
01:37:01 <kallisti> @@ @pl @undo { x <- m; y <- m2; f x y }
01:37:01 <lambdabot> Parse error at "{" (column 1)
01:37:06 <kallisti> @@ @pl @undo do { x <- m; y <- m2; f x y }
01:37:07 <lambdabot> (m2 >>=) . f =<< m
01:37:08 <kallisti> lol
01:38:20 <kallisti> :t liftM
01:38:21 <lambdabot> forall a1 r (m :: * -> *). (Monad m) => (a1 -> r) -> m a1 -> m r
01:38:22 <kallisti> :t liftM2
01:38:23 <lambdabot> forall a1 a2 r (m :: * -> *). (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
01:38:42 <kallisti> :t join . liftM2
01:38:43 <lambdabot> forall a2 r (m :: * -> *). (Monad m) => (a2 -> a2 -> r) -> m a2 -> m r
01:39:14 <kallisti> :t join .: liftM2 undefined
01:39:15 <lambdabot> forall (m :: * -> *) a a1 a2. (Monad m) => m a1 -> m a2 -> m a
02:21:54 -!- myndzi has joined.
02:24:38 -!- DCliche has quit (Quit: SLEEP, GLORIOUS SLEEP).
02:27:45 <variable> just a though for a new esolang
02:28:11 <variable> a language which has data disappear if you don't access it after some amount of time
02:36:08 <zzo38> variable: Yes I have thought of something similar too; see "Silly Emplosions"
02:36:39 -!- pikhq_ has joined.
02:36:46 -!- pikhq has quit (Ping timeout: 252 seconds).
02:37:24 <zzo38> "If you leave a variable for too long without assigning a value, the variable will lose its value."
02:37:40 <variable> ya
02:38:54 -!- myndzi has quit.
02:39:02 -!- myndzi has joined.
02:42:28 <zzo38> I realized now, in the Pure BF implementation, there is things such as (t $ Sum 0) but I think it is really same as (extract t)
02:44:06 <zzo38> For the (->) comonad, extract = ($ mempty)
02:54:43 <Sgeo> -> is a comonad?
03:03:57 <zzo38> Yes, but it require the input type to be monoid
03:04:46 <zzo38> You can also make an indexed comonad which is similar but has the input type being a category instead
03:06:56 <zzo38> This is such a program using -> comonad: http://esolangs.org/wiki/Pure_BF/Implementation
03:08:34 -!- azaq23 has quit (Quit: Leaving.).
03:14:30 <kallisti> :t uncurry
03:14:31 <lambdabot> forall a b c. (a -> b -> c) -> (a, b) -> c
03:30:57 <kallisti> http://hpaste.org/56825
03:31:02 <kallisti> anyway I can make this slightly less terrible?
03:34:50 <Sgeo> kallisti, update
03:35:41 <zzo38> kallisti: I don't know
03:35:52 <kallisti> zzo38: it may be hard to discern what it does.
03:36:31 <kallisti> the idea is that I have a function called stepLine, which generates a walk on the board starting from some coordinate and direction (the Move type is a Coord Direction pair)
03:36:55 <kallisti> it walks forward and if it ends when it runs into a piece or when it reaches the edge of the board.
03:37:10 <kallisti> if it encounters a portal that's facing the opposite direction of the direction of travel
03:37:13 <kallisti> it goes through the portal
03:37:19 <kallisti> so it can possibly be an infinite walk.
03:37:39 <kallisti> s/if it ends/it ends/
03:39:12 <kallisti> so this function extends that simple walk by applying a function whenever a portal is encountered
03:39:39 <kallisti> the function receives the location of the portal (as a Move) and the location of where the portal takes it.
03:40:19 <kallisti> whenever it returns Nothing wrapped in a monad, the walk halts
03:40:45 <kallisti> otherwise it returns Just the value to append to the walk list.
03:41:08 <kallisti> I use the State monad, but I generalized the type signature to any Monad/Functor
03:41:33 <zzo38> Can it work with any applicative functor?
03:41:55 <kallisti> hm
03:42:01 <kallisti> I think so?
03:42:07 <kallisti> maybe if I change the returns to pures
03:42:59 <kallisti> the point is that I want to keep track of every portal I've visited, and then halt the walk when I've reached the same portal again.
03:43:07 <kallisti> to avoid an infinite loop.
03:43:30 <kallisti> State seemed like the easiest way to not only keep track of the portals, but to keep track of them between multiple walks from a given starting point.
03:43:53 <kallisti> but... I'm wondering if there's a better way.
03:45:01 <kallisti> walkWithPortals will be used to: a) figure out the valid moveset for a given piece b) detect loops when a projectile is fired
03:45:35 <kallisti> possibly other things I haven't considered. it's a useful bit of code that removes some ugly, duplicate code.
03:46:31 <kallisti> a small change I was wondering about:
03:46:34 <kallisti> maybe (return Nothing) (uncurry portalF) mTuple
03:46:40 <kallisti> can I avoid this?
03:48:16 <kallisti> step' returns a single step, ignoring portals, step returns a single step forward and follows portals
03:48:28 <kallisti> so to detect portals I check the result of both against each other... if they're different then we've hit a portal.
03:49:23 <kallisti> but they both return Maybes... because their may be no step to take (you're in front of a piece or at the edge of the board)
03:49:32 <kallisti> *there
03:51:57 <kallisti> it's probably better if I just paste the whole code
03:51:58 <kallisti> http://hpaste.org/56828
03:57:54 <kallisti> zzo38: what's the term in chess for pieces that move in cardinal directions?
03:57:59 <kallisti> do they use orthogonal?
04:38:07 <kallisti> @pl (\x -> map (f x))
04:38:07 <lambdabot> map . f
04:38:16 <kallisti> @pl (\x y -> map (f x) y)
04:38:16 <lambdabot> map . f
04:38:23 <kallisti> hm
04:38:50 <kallisti> @pl (\x y -> f . g . h $ map (f x) y)
04:38:50 <lambdabot> ((f . g . h) .) . map . f
04:39:45 <kallisti> @pl (\x -> f . g . h . map (f x))
04:39:45 <lambdabot> ((f . g . h) .) . map . f
04:44:06 <kallisti> Haskell kind of forces you to get good at naming things. :P
04:44:43 <monqy> nope
04:47:55 <kallisti> either that or use a lot of letters.
04:48:18 <kallisti> or just be really bad at naming things still
04:48:19 <kallisti> I guess
04:48:39 <monqy> all of my names are just lots of apastrafes
04:48:46 <kallisti> bad
04:48:59 <kallisti> m'''
04:49:08 <kallisti> not to be confused with m''
04:49:11 <kallisti> and m'
04:49:12 <kallisti> or...
04:49:15 <kallisti> do you actually just use '?
04:49:16 <kallisti> '''
04:49:22 <kallisti> oh wait can't
04:49:51 <monqy> i put an underscore before it
04:50:28 <kallisti> > _' = 2 in _'
04:50:29 <lambdabot> <no location info>: parse error on input `='
04:50:32 <kallisti> > let _' = 2 in _'
04:50:33 <lambdabot> 2
04:51:19 * kallisti takes note of that one for a future Haskell obfuscator
04:51:28 <kallisti> though the ideal obfuscator just applies @pl to everything
04:51:36 <kallisti> so there won't be any variables
04:53:20 <Jafet> let _'_ = '_'
04:54:32 <kallisti> @hoogle (<|>)
04:54:33 <lambdabot> Control.Applicative (<|>) :: Alternative f => f a -> f a -> f a
04:54:33 <lambdabot> Text.Parsec.Prim (<|>) :: (ParsecT s u m a) -> (ParsecT s u m a) -> (ParsecT s u m a)
04:54:33 <lambdabot> Text.ParserCombinators.Parsec.Prim (<|>) :: (ParsecT s u m a) -> (ParsecT s u m a) -> (ParsecT s u m a)
04:55:52 <kallisti> @unpl (\(a,b) -> (f a, f b))
04:55:53 <lambdabot> (\ (a, b) -> (f a, f b))
04:55:56 <kallisti> @pl (\(a,b) -> (f a, f b))
04:55:57 <lambdabot> f *** f
04:56:32 <kallisti> @pl (\a b -> (f a, f b))
04:56:32 <lambdabot> (. f) . (,) . f
04:57:56 <kallisti> is there anything dangerous about FlexibleContexts?
04:58:45 <Jafet> It's a gateway to IncoherentInstances
04:59:35 <kallisti> ...so
04:59:39 <kallisti> not dangerous?
05:00:06 <kallisti> I basically want to generalize my State code to MonadState, despite the fact that it uses a specific state type...
05:00:22 <Jafet> Not by itself. But you often don't use it by itself.
05:14:20 -!- oerjan has joined.
05:15:32 -!- MDude has changed nick to MSleep.
05:22:18 <kallisti> @hoogle (Maybe a, Maybe b) -> Maybe (a,b)
05:22:18 <lambdabot> No results found
05:22:27 <kallisti> heh
05:22:57 <oerjan> uncurry (liftM2 (,))
05:23:00 <oerjan> :t uncurry (liftM2 (,))
05:23:01 <lambdabot> forall a1 a2 (m :: * -> *). (Monad m) => (m a1, m a2) -> m (a1, a2)
05:23:45 <kallisti> walkWithPortals :: (Functor m, Monad m) => Board -> (Move -> Move -> m (Maybe Move)) -> Move -> m [Move]
05:23:51 <kallisti> oerjan: do you walk with portals?
05:23:59 <oerjan> sadly, no
05:24:15 <kallisti> also, how obscene is that type?
05:24:22 <kallisti> it looks pretty obscene to me.
05:24:49 <oerjan> well Functor _should_ be implied by Monad. if you replace fmap by liftM, it might do.
05:24:59 <oerjan> *_should_ have been
05:25:11 <kallisti> no it wasn't implied because I'm using fmap
05:25:23 <kallisti> I don't really like the liftM family but... I'll try it.
05:25:49 <oerjan> i mean, in a general why the heck doesn't haskell do it, oh you mean it's been discussed a googol times before, ok...
05:25:56 <oerjan> *+sense
05:26:20 <kallisti> linearWalk :: (MonadState (S.Set Move) m) => Board -> Move -> m [Move]
05:26:22 <kallisti> FLEXIBLECONTEXTS OSHI
05:26:33 <oerjan> while raisins are dancing around you, hysterically.
05:26:48 <kallisti> I like how linearWalk actually isn't really very linear at all.
05:26:53 <kallisti> depending on what you mean by linear...
05:27:12 <oerjan> flexiblecontexts is trivial, another thing that should have been in haskell by default.
05:27:18 <kallisti> in an absolute sense it is not a continuous line. however, when thinking with portals, it's perfectly linear.
05:27:42 <oerjan> curvaceousWalk?
05:28:01 <kallisti> I guess I should call it like linearWalkButCatchesInfiniteLoops
05:28:11 <kallisti> and then call stepLine linearWalk
05:29:10 <kallisti> concatLinearWalks :: Board -> [Move] -> [Move]
05:29:12 <kallisti> concatLinearWalks = ((join . (`evalState` S.empty)) .) . mapM . linearWalk
05:29:16 <kallisti> BOOM PUNCHLINE
05:33:51 <oerjan> um the join there is actually concat, no? it's outside the monad after all.
05:33:56 <kallisti> yes
05:34:06 <kallisti> is that confusing?
05:34:09 <oerjan> might be clearer to use concat, then
05:34:39 <kallisti> done. :)
05:35:14 <kallisti> can you tell what it does by chance? :P
05:35:37 <kallisti> data Move = Move Coord Direction
05:36:19 <kallisti> linearWalk (Move c d) starts its walk from point c traveling in direction d
05:36:29 <kallisti> *linearWalk board (Move c d)
05:38:05 <kallisti> hmmm wait is State a monoid?
05:38:07 <oerjan> well it concatenates results of linearWalk, each linearWalk starting with the end state of the previous one
05:38:19 <kallisti> yes
05:38:26 <oerjan> i don't know why that is an interesting operation.
05:38:50 <kallisti> it probably isn't. it's just the first time I've actually used State for anything useful. :P
05:39:13 <kallisti> in this case the state is a set of every portal we've encountered along the walk
05:39:20 <oerjan> oh wait hm
05:39:20 <oerjan> linearWalk actually just takes one step, right
05:39:20 <kallisti> the walks short circuit when they encounter the same portal again.
05:39:24 <kallisti> no
05:39:35 <kallisti> zero or more
05:39:45 <oerjan> more than one?
05:39:58 <kallisti> well it could take zero if it attempts to walk into another piece
05:40:10 <kallisti> or off the edge of the board.
05:40:25 <kallisti> but otherwise takes one or more.
05:40:30 <oerjan> the zero is obvious. what i don't understand is why you'd want more than one.
05:40:51 <kallisti> to define movesets for each piece.
05:41:31 <oerjan> oh. so it's not some walk a piece would actually try to take, now it makes more sense
05:41:41 <kallisti> yes it's a list of possible moves.
05:41:43 <oerjan> (the concatenated one)
05:42:01 <kallisti> which can be a tricky thing to figure out on a board with four portals on it.
05:43:18 <oerjan> heh
05:43:31 <kallisti> there may be a more efficient way to calculate that I don't know
05:43:45 <kallisti> but it seemed easiest to just define what the set of moves is and then traverse it to see if the attempted move is valid.
05:44:05 <oerjan> do you exit a portal in the same direction, or rotated
05:44:09 <kallisti> maybe use a set instead of a list? I don't know, that's a lot of inserts for basically only probably one lookup.
05:44:21 <kallisti> oerjan: the portal forces your new direction
05:44:26 <kallisti> so... whatever that means
05:44:30 <kallisti> phrased in those terms that you just said. :P
05:44:42 <kallisti> rotated I guess.
05:44:42 <oerjan> which means loops need to take into account what direction you are traveling
05:45:00 <kallisti> believe so yes.
05:45:09 <kallisti> I'm not entirely sure about that
05:45:15 <kallisti> but it currently does take that into account.
05:45:22 <kallisti> there's only one direction from which you can enter a given portal
05:45:28 <kallisti> so... just keeping track of the coordinate should be enough
05:45:56 <oerjan> ok
05:46:27 <kallisti> unfortunately I'll probably need to rewrite some of this code or generalize it even further in order to get it to work with projectiles....
05:47:17 <kallisti> oh hmmm
05:47:19 <kallisti> just got an idea
05:47:58 <kallisti> oerjan: http://hpaste.org/56830 hi can you make walkWithPortals less ugly?
05:48:03 <kallisti> actually I might be doing that soon.
05:48:15 <kallisti> I think I'm going to make walkWithPortals a special case of a more general function
05:49:01 <oerjan> ok
05:49:23 <kallisti> basically walkWithPortals applies the function you supply it whenever it encounters a portal on a walk (note that this kind of walk can possibly be infinite -- this is before the short-circuiting happens)
05:49:29 <kallisti> but
05:49:48 <kallisti> I can just generalize that to "apply a function when you land on any piece"
05:49:54 <kallisti> and that basically lets me do all the other things I want to do.
05:51:14 * kallisti is not sure if he's going about it the right way.
05:51:27 <kallisti> this is the first large Haskell program I've written. :)
05:52:39 * oerjan has never written a large haskell program, he thinks
05:54:00 <kallisti> hmmm I should test the code I currently have.
05:54:05 <kallisti> that's going to be annoying...
05:54:48 <kallisti> the Maybe monad has been my favorite for this section of code.
05:58:01 <kallisti> is there anything that short circuits on Just instead of Nothing?
05:58:14 <kallisti> > Just 2 <|> Nothing
05:58:15 <lambdabot> Just 2
05:58:22 <kallisti> > Nothing <|> Just 2
05:58:23 <lambdabot> Just 2
05:58:27 <kallisti> awwwwwwwww yeah
05:58:36 <kallisti> that's excellent
05:59:11 <kallisti> this means I can write "piece handlers"
05:59:17 <kallisti> and then just piece them together
05:59:18 <kallisti> with that.
05:59:36 <kallisti> or, well, something similar.
05:59:50 -!- itidus21 has joined.
05:59:55 <kallisti> itidus21: SUP DAWG
06:00:04 <oerjan> the soup dog
06:00:09 <kallisti> dup dog
06:00:12 <oerjan> bringing soup to everyone
06:00:38 <itidus21> i see in topic they think spotted marsh elliott extinct :-s
06:00:46 <oerjan> just don't be too picky on the hygiene.
06:01:06 <oerjan> itidus21: in this channel yes. it's been spotted in neighboring ones.
06:01:37 <kallisti> IRC is a weird place
06:01:54 -!- Phantom_Hoover has joined.
06:01:56 <kallisti> you can be in multiple locations at once, and your neighbors are defined by similarity in what they talk about.
06:02:04 -!- oerjan has set topic: Now open for Americans to liberate | Get your esoil and esoline here! | Glorious optator institutes permanent ban penalty for power tripping | Weapons of mass banning "just monoids in the category of endofunctors, what's the problem?" | Spotted marsh elliott still unspotted | Gregorian chants outlawed, "American" | http://codu.org/logs/_esoteric/.
06:02:50 <kallisti> there are so many... jokes
06:03:02 <oerjan> what, in the topic?
06:03:07 <kallisti> yes
06:04:42 -!- oerjan has set topic: Now open for Americans to liberate | Get your esoil and esoline here! | Production of tripless power cables start, "mandatory security change" | Weapons of mass banning "just monoids in the category of endofunctors, what's the problem?" | Spotted marsh elliott still unspotted | Gregorian chants outlawed, "American" | http://codu.org/logs/_esoteric/.
06:05:56 <kallisti> oerjan: I wouldn't be surprised if there's some kind of "GENERALIZE GRAPH WALK COMBINATOR" that could result from this stuff....
06:05:59 <kallisti> yes
06:06:01 <kallisti> GGWC
06:06:08 -!- oerjan has set topic: Now open for Americans to liberate | Get your esoil and esoline here! | Production of tripless power cables start, "mandatory security change" | Glorious optator briefly unmentioned in topic, editor exiled | Spotted marsh elliott still unspotted | Gregorian chants outlawed, "American" | http://codu.org/logs/_esoteric/.
06:06:42 <kallisti> how do you pronounce "esoil?
06:06:50 <kallisti> s/\?/"?/
06:07:03 <kallisti> s oil?
06:07:05 <oerjan> straight forward duh
06:07:22 <kallisti> at first sight I thought it was e soil.
06:08:09 * oerjan finds out he's not quite got the right pronunciation of "esoteric"
06:08:30 <kallisti> I remember when I discovered that. :P
06:09:13 * itidus21 suddenly realizes i have wrong pronunciation also
06:09:19 <kallisti> lol
06:09:46 <itidus21> i have been subverbalizing it as E-so-teric all along
06:09:57 <itidus21> but reading this its obviously S-O-teric
06:10:30 <itidus21> or it could be
06:10:35 <kallisti> at first I pronounced it as eh-SAW-teric, and still think that sounds good. :P
06:10:46 <itidus21> maybe it is
06:10:51 <itidus21> im just guessing
06:11:02 <kallisti> no it's S-O-teric as you say.
06:11:10 <kallisti> though the O coulkd be a schwa as well.
06:12:28 <oerjan> (UK) IPA: /ˌɛs.əʊˈtɛɹ.ɪk/, SAMPA: /%Es.@U"tEr.Ik/; (US) IPA: /ˌɛs.əˈtɛɹ.ɪk/
06:12:50 <oerjan> someone here might even be able to see all the symbols
06:13:00 * kallisti can see them!
06:13:08 <oerjan> (it's fine in my browser, just not in putty)
06:13:20 <itidus21> "In words attributed to Art Babbitt, an animator with the Walt Disney Studios: "Animation follows the laws of physics unless it is funnier otherwise." "
06:14:07 <kallisti> itidus21: it could also be more fantastic
06:14:09 <kallisti> instead of funny
06:14:14 <kallisti> for example, Dragonball Z.
06:14:26 <kallisti> so realistic or funny or BADASS
06:14:30 <kallisti> are the options. :P
06:14:30 <itidus21> yeah im pretty fixated on dragonball z physics
06:14:33 <kallisti> lol
06:15:13 <kallisti> hm
06:15:23 <kallisti> these explicit board parameters are getting in my way.
06:15:43 <itidus21> *small grin* but up until now i have focused too much on japanese comical physics
06:16:12 <kallisti> maybe I should combine Move and Board into something....
06:16:12 <itidus21> the article heer reminds me that teh west did their own innovations too
06:17:37 <oerjan> <zzo38> I realized now, in the Pure BF implementation, there is things such as (t $ Sum 0) but I think it is really same as (extract t)
06:17:41 <oerjan> ah right
06:18:46 <oerjan> > (Sum 1, Product 5) `mappend` (Sum 2, Product 3)
06:18:46 <lambdabot> (Sum {getSum = 3},Product {getProduct = 15})
06:18:50 <oerjan> yay
06:19:27 <oerjan> zzo38: you could make a paintfuck implementation with the (Sum Int, Sum Int) monoid :P
06:19:32 <oerjan> i think
06:21:11 <oerjan> @tell zzo38 Sounds like you could generalize the monoid for your pure BF implementation, e.g. make a paintfuck implementation with the (Sum Int, Sum Int) monoid :P
06:21:12 <lambdabot> Consider it noted.
06:21:23 <kallisti> I wonder just how good GHC is at common subexpression elimination.
06:22:10 <oerjan> kallisti: afair it tries not to be smarter than the programmer, since that can cause space leaks
06:22:50 <oerjan> so if you want something elimated, give it a name
06:22:50 <oerjan> *-in-
06:23:17 <kallisti> I was referring to common subexpression elimination after inlining.
06:23:26 <kallisti> which I can't do myself.
06:23:31 <oerjan> oh.
06:24:17 <oerjan> maybe you can use {-# NOINLINE #-} somehow (i've never optimized much)
06:24:28 <kallisti> er, no that's the opposite of what I want.
06:24:35 <kallisti> I want it to inline and CSE :P
06:24:58 <kallisti> I suppose I could just find... a better way to write my code. INSTEAD
06:24:59 <kallisti> sheesh
06:25:14 <monqy> premature optimisation premature optimisation
06:25:26 <monqy> unless
06:25:32 <monqy> your code is awful?? and rewriting it would be good??
06:25:33 <monqy> help
06:25:38 <kallisti> probably.
06:26:22 <oerjan> you might also ask someone who actually knows the answer, i guess.
06:29:40 <kallisti> > many 1
06:29:41 <lambdabot> No instance for (GHC.Show.Show (f [a]))
06:29:41 <lambdabot> arising from a use of `M36260297...
06:29:57 <kallisti> > many 1 :: Maybe Int
06:29:58 <lambdabot> Couldn't match expected type `GHC.Types.Int'
06:29:58 <lambdabot> against inferred type ...
06:30:38 <kallisti> > const Just 2 <|> const Just 3 $ 5
06:30:39 <lambdabot> No instance for (Control.Applicative.Alternative ((->) a))
06:30:40 <lambdabot> arising from ...
06:30:46 <kallisti> this should totally be a thing.
06:32:26 <kallisti> oh wait
06:32:36 <kallisti> > const (Just 2) <|> const (Just 3) $ 5
06:32:37 <lambdabot> No instance for (Control.Applicative.Alternative ((->) a))
06:32:38 <lambdabot> arising from ...
06:32:40 <kallisti> actually this should be a thing.
06:32:43 <oerjan> i understand many and some are useless for monads which are not essentially parser monads
06:33:05 <oerjan> you need a monad in which the _same_ action can succeed or fail at different times.
06:33:39 <oerjan> ok State can do that. but not Maybe, [], Reader or Writer.
06:33:39 <kallisti> hi what does <|> on functions look like.
06:33:48 <zzo38> oerjan: Maybe you could make a paintfuck implementation too, if you like to do so. I have no intention to do so at this time
06:33:49 <lambdabot> zzo38: You have 1 new message. '/msg lambdabot @messages' to read it.
06:34:07 <oerjan> zzo38: nah i'm just pointing out the connection
06:34:41 <oerjan> :t sin <|> cos
06:34:42 <lambdabot> forall a. (Floating a, Alternative ((->) a)) => a -> a
06:35:01 <zzo38> You cannot use <|> on functions
06:35:21 <oerjan> :t Just <|> const Nothing
06:35:21 <oerjan> now what
06:35:21 <oerjan> :t Just <|> const Nothing
06:35:22 <lambdabot> forall a. (Alternative ((->) a)) => a -> Maybe a
06:35:22 <lambdabot> forall a. (Alternative ((->) a)) => a -> Maybe a
06:35:26 <kallisti> well I was thinking if its return value was <|>
06:35:30 <kallisti> er
06:35:32 <kallisti> was Alternative
06:35:33 <oerjan> kallisti: seems there is no instance defined
06:35:44 <kallisti> ....I'm having trouble figuring out what the instance looks like. :P
06:36:02 <kallisti> because how do you refer to the return value of the function?
06:36:08 <oerjan> kallisti: probably the same as most of the weird Num etc. instances
06:36:29 <oerjan> (f <|> g) x = f x <|> g x
06:36:31 <zzo38> If there is <|> then there must be empty as well, where the type signature for empty implies that it cannot be the same as any pure and that (<$> empty) = const empty due to the law fmap id = id
06:36:50 <oerjan> empty x = empty
06:37:07 <kallisti> I mean what does the instance header look like
06:37:13 <kallisti> that's... what I can't figure out. :P
06:37:30 <oerjan> oh duh right
06:38:12 <oerjan> a -> f b doesn't have the b in the right position to make an Applicative instance.
06:38:35 <kallisti> so I guess I'll just....
06:38:40 <kallisti> write my own function. what should I call it?
06:38:49 <oerjan> newtype wrapper can do it :P
06:38:55 <kallisti> gross.
06:38:57 <oerjan> which is actually what ReaderT is, i think
06:39:23 <oerjan> :t ReaderT
06:39:24 <lambdabot> forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
06:40:16 <oerjan> > runReaderT (ReaderT Just <|> ReaderT (const Nothing)) 5
06:40:17 <lambdabot> Just 5
06:40:52 <kallisti> eh that kind of defeats the purpose for me
06:40:55 <kallisti> I'll just write my own function.
06:42:18 <zzo38> The type signature of empty (and mzero) also implies the left zero law (mzero >> x = mzero) due to the (>>= return) law that (join . return = join . fmap return = id)
06:42:49 <oerjan> what's your f in this, anyway? if the f x monoid instance fits that f alternative instance, you could use a monoid instance for -> instead
06:43:01 <zzo38> It is not necessary to make the left zero law explicit in the definition
06:43:02 <oerjan> alas, Maybe is well known _not_ to match them
06:43:07 <kallisti> Maybe
06:43:19 <kallisti> it's okay I'm doing something else. :>
06:43:26 <zzo38> Not to match what?
06:43:45 <oerjan> zzo38: mappend and <|> don't do the same thing for Maybe
06:43:54 <kallisti> actually I could make an alternative instance for a very very specific function. :P
06:44:27 <zzo38> oerjan: Yes. That is so that they can make a different thing for mappend
06:44:38 <oerjan> > Just "test" <|> Just "so"
06:44:39 <lambdabot> Just "test"
06:44:45 <oerjan> > Just "test" `mappend` Just "so"
06:44:45 <zzo38> But you could make a wrapper that makes mappend do the <|>
06:44:46 <lambdabot> Just "testso"
06:45:10 <zzo38> Another wrapper could make mappend to do the (liftA2 mappend)
06:45:15 <oerjan> zzo38: well but a newtype wrapper defeats kallisti's purpose of getting something elegant
06:45:25 <kallisti> YEP
06:45:49 <zzo38> oerjan: Then, implement the InstanceDisambiguation extension proposal that I have written
06:45:50 <oerjan> there are already _several_ Monoid wrappers for Maybe
06:46:43 <zzo38> oerjan: I don't mean only for Maybe. I meant a wrapper making mappend do the <|> or the (liftA2 mappend) etc for any general Alternative or Applicative of monoid
06:48:49 <zzo38> Although I think, as well as making join a class method of Monad, make liftPair :: (f x, f y) -> f (x, y) a class method of Applicative since it is sometimes very useful, and you could have <*> and liftPair default methods defined in terms of each other
06:49:58 <zzo38> And then I try to think, if you can somehow make a Coapplicative with a kind of liftPair other way
06:50:26 <oerjan> zzo38: i am not sure how useful liftPair as a method is, since i think usually a liftPair implementation would just be putting (,) in the <*> definition
06:50:53 <oerjan> and then, why not make it general in the first place
06:52:05 <zzo38> Also see this: http://en.wikipedia.org/wiki/Monoidal_monad It seems similar to my "liftPair" idea but describes how a monad can be applicative functor as well, as far as I can tell
06:52:14 <kallisti> walkWith board (followPortal `orRule` stopOnPiece) startMove
06:52:18 <kallisti> holy crap that's awesome.
06:53:28 <zzo38> oerjan: There is the reason not make it general; you can define <*> too; the liftPair would just be another way that describes it without function (putting the use of function in fmap instead)
06:53:57 <zzo38> Like how, join also doesn't require the function as a parameter
06:54:05 <kallisti> I wonder if orRule should be left associative or right associative.
06:54:28 <kallisti> same associative as <|> I think
06:54:30 <kallisti> which is.... left?
06:54:51 <zzo38> If you type :info <|> in GHCi then they will tell you the fixity
06:55:02 <kallisti> pretty sure it's left based on its short circuting behavior with Maybe
06:55:18 <zzo38> It doesn't matter because it is associative
06:55:21 <kallisti> > Nothing <|> Just 2 <|> Nothing
06:55:22 <lambdabot> Just 2
06:55:26 <kallisti> oh right
06:55:37 <oerjan> zzo38: the difference is that i find it hard to think of a liftPair definition which doesn't use (,) somewhere, possibly hidden in something like curry, but still. while a join definition does not have to contain any obvious correspondence to >>='s function argument.
06:55:39 <kallisti> > Just 3 <|> Just 2 <|> Nothing
06:55:40 <lambdabot> Just 3
06:56:00 <kallisti> yeah should be left associative in this case.
06:56:48 <zzo38> kallisti: But <|> is associative by law, so (Just 3 <|> Just 2) <|> Nothing = Just 3 <|> (Just 2 <|> Nothing)
06:57:07 <kallisti> ah, indeed.
06:57:37 <oerjan> :t (0$0 <|>)
06:57:38 <lambdabot> The operator `<|>' [infixl 3] of a section
06:57:38 <lambdabot> must have lower precedence than that of the operand,
06:57:38 <lambdabot> namely `$' [infixr 0]
06:57:38 <zzo38> oerjan: That is true, that is a difference. But at least "monoidal monad" in mathematics (described by the Wikipedia article) seem to be similar to liftPair
06:58:19 <oerjan> zzo38: yes, but in mathematical category theory, products are much more fundamental than in haskell
07:00:38 <oerjan> <kallisti> pretty sure it's left based on its short circuting behavior with Maybe <-- huh, that actually seems stupid. right would short circuit better.
07:01:04 <oerjan> just like with || and &&
07:01:06 <oerjan> hm...
07:01:13 <oerjan> > (0$0 ||)
07:01:14 <lambdabot> The operator `GHC.Classes.||' [infixr 2] of a section
07:01:14 <lambdabot> must have lower ...
07:01:17 <oerjan> > (0$0 &&)
07:01:18 <lambdabot> The operator `GHC.Classes.&&' [infixr 3] of a section
07:01:18 <lambdabot> must have lower ...
07:01:38 <kallisti> infixl 3 <|>
07:02:04 <oerjan> i have had a hunch for a while that the Applicative operator fixities are not well thought out. (for one thing, they're _different_ from the corresponding Monad ones)
07:02:30 <oerjan> > (0$0 `mplus`)
07:02:31 <lambdabot> The operator `Control.Monad.mplus' [infixl 9] of a section
07:02:31 <lambdabot> must have l...
07:02:41 <oerjan> ok that one doesn't actually _have_ one.
07:02:42 <zzo38> oerjan: Yes they are different, and sometimes it is useful that they are difference. But yes it still does seem mixed up you are correct about that
07:04:13 <oerjan> <zzo38> If you type :info <|> in GHCi then they will tell you the fixity <-- also my (0$0 `op`) trick for lambdabot
07:04:30 <zzo38> O, yes, that too.
07:05:18 <kallisti> mmmm this is so good
07:05:20 <kallisti> this fixes so many things.
07:11:05 <kallisti> oerjan: what do you mean that right associative would short circuit better?
07:11:21 -!- pikhq_ has quit (Ping timeout: 240 seconds).
07:11:36 -!- pikhq has joined.
07:11:53 <oerjan> kallisti: if a <|> b <|> c is parsed as a <|> (b <|> c), you just need to evaluate the a to know if it causes a short circuit
07:12:10 <kallisti> oh right
07:12:23 <kallisti> I'm bad at associativity. :P
07:13:10 <kallisti> wow, I've written a lot of code.
07:13:23 <kallisti> this is the most Haskell I've written.
07:13:34 <zzo38> How does "in mathematical category theory, products are much more fundamental than in haskell"? Product type are useful in Haskell programming too (since really, you can do many the same as mathematics)
07:13:53 <oerjan> and even if <|> _doesn't_ shortcut ... for [], (<|>) = (++) and ++ has better complexity when right associated
07:17:25 <oerjan> zzo38: useful, sure, but in category theory products are a limit construction, and afaict used to _define_ two-argument morphisms. and you don't get currying unless your category is cartesian closed.
07:17:46 <oerjan> so you _need_ products in a more fundamental way.
07:18:22 <zzo38> oerjan: Yes, I suppose that is why some monad are "monoidal monads"; when I read that I thought, is all monads applicative functors as long as it is a cartesian closed category? Or is there something else?
07:19:08 <oerjan> zzo38: i don't know, monoidal monads reaches the part of category theory that is a bit too heavy for my brain nowadays.
07:20:23 <oerjan> zzo38: i recall some people mentioned recently, maybe here, that without cartesian closed category there is a distinction between monads and _strong_ monads. i don't know what that is though.
07:20:47 <zzo38> Because, I know in Haskell, all monads can be applicative functors. I would like to know if that applies to all cartesian closed categories, or if it is a weaker or a stronger requirement than this.
07:21:15 <zzo38> oerjan: Yes I have read some things about strong monads, and that in Haskell, all functors are strong
07:21:16 <oerjan> argh that requires monoidal category too. there's no escape :P
07:21:40 <kallisti> linearWalker :: WalkRule
07:21:40 <kallisti> linearWalker = followPortal `orRule` stopAtPiece
07:21:47 <kallisti> the terminology is just getting more ridiculous as we speak.
07:23:32 <zzo38> And anyways, the Arrow class in Haskell is defined using product types.
07:24:18 <oerjan> zzo38: hm, cartesian closed categories allow you to define monads in terms of >>= don't they, and doesn't the rest of applicative follow from that?
07:24:43 <oerjan> zzo38: yes, but i think that's considered a somewhat ugly fact about arrows.
07:25:28 <kallisti> hm
07:25:37 <oerjan> although some consider the rampant use of arr also an ugly fact, and i've read some suggesting a weaker arrow class without it, and _just_ product plumbing, which would be useful for circuit-like things
07:25:51 <oerjan> *weaker variant of
07:26:12 <kallisti> what would happen if.....
07:26:23 <kallisti> I passed these walk rules, the rule that they're a part of?
07:26:42 <kallisti> so that they can advance forward using all the rules.
07:26:54 <kallisti> hm that sounds like a continuation actually.
07:27:19 <oerjan> kallisti: sounds like how you do recursion in lambda calculus
07:27:31 <zzo38> I think arr ought to be a different class. I did write a module (not yet published) that puts arr in a different class and can use any type instead of (,) as another class parameter (which means no separate class in needed for ArrowChoice since you can use the dual category)
07:27:46 <kallisti> oerjan: I want to define a rule called walkAroundPiece
07:28:09 <kallisti> which will, if it encounters a piece, step forward beyond it.
07:28:19 <kallisti> but it has to know what the walk rule is
07:28:23 <kallisti> which is information it currently doesn't have.
07:28:35 <oerjan> i think i need to finish reading this website which keeps leaking memory ->
07:28:36 <zzo38> I put arr in a different class called CatFunctor from any one category to another, and a different name. The class methods for CatArrow are also given different names and has two parameters instead of just one
07:29:53 <kallisti> hmmm I think I could better structure this is a Cont maybe?
07:33:52 <kallisti> ....
07:33:53 <kallisti> I
07:34:03 <kallisti> I want to, so badly, name this constructor field
07:34:04 <kallisti> boardWalk
07:34:14 <kallisti> but that actually doesn't make any sense.
07:44:32 <Sgeo> Apparently, Notch is a fan of Order of the Stick
07:44:39 <kallisti> RecordPuns is a weird name for RecordPuns
07:47:04 <zzo38> class Category c => CatArrow c p where { arr1 :: c x y -> c (p x z) (p y z); arr2 :: c x y -> c (p z x) (p z y); mirror :: c (p x y) (p y x); (*+*) :: c x y -> c x' y' -> c (p x x') (p y y'); (&|&) :: c x y -> c x y' -> c x (p y y'); } It can define arr1 in terms of arr2 and mirror, arr2 in terms of arr1 and mirror, *+* in terms of arr1 and arr2; can it define mirror in terms of &|& and arr1 and arr2?
07:47:21 <oerjan> argh IE will let me turn off scripts on the site but _not_ enable them on a subpage which i want them on (you _cannot_ put anything explicitly into the default region, only the restricted and cleared ones)
07:47:41 <oerjan> (yeah i know you'll just laugh at me using IE)
07:47:57 <kallisti> haha IE great funny
07:48:03 -!- ChanServ has set channel mode: +o oerjan.
07:48:15 <zzo38> I think you can add one more zone using the registry editor
07:48:16 -!- oerjan has kicked kallisti Just remember, there are consequences!.
07:48:22 -!- kallisti has joined.
07:48:24 <kallisti> egads!
07:48:29 -!- oerjan has set channel mode: -o oerjan.
07:48:46 <kallisti> stupid optators tripping on the power
07:48:59 <oerjan> i didn't trip, i was pushing you
07:49:19 <kallisti> am I a bad person for using record puns?
07:49:28 <oerjan> no, puns are always good
07:49:49 <kallisti> I think at this point I'm probably overcomplicating things.
07:50:07 <kallisti> but I can't think of a more general way to do it...
07:50:50 <oerjan> wait, more general implies _less_ complicated, in haskell?
07:51:08 <kallisti> no
07:51:12 <kallisti> and I think no for any language. :P
07:51:21 <kallisti> well...
07:51:30 <kallisti> I don't know this is easier than rewriting a bunch of code.
07:51:48 <kallisti> and in the likely event that I change some rules this will be pretty easy to modify.
07:55:09 <kallisti> oh wait I don't even need this rule...
07:55:17 <kallisti> or wait, yes I do...
08:14:50 -!- Vorpal has joined.
08:15:47 <zzo38> f :: Natural -> Natural -> Natural; f 0 0 = 0; f x 0 = x ^ church x (f $ pred x) (x ^ x); f x y = join (^) $ f x (pred y); z :: Natural; z = join (^) $ f 3 0;
08:18:03 <kallisti> uh oh....
08:19:02 <oerjan> zzo38: primitive recursive, i suspect
08:19:17 <zzo38> Questions: [1] How large is z compared to other large numbers? [2] How much memory do you need to calculate it? [3] How long will it take for the program to complete? [4] What properties can be figured out? [5] What is the point of doing such things?
08:19:20 <oerjan> oh hm or
08:19:48 <oerjan> maybe not...
08:21:02 <zzo38> (By "church" I mean that the function (f $ pred x) should be applied x times)
08:21:34 <zzo38> oerjan: Why not?
08:21:35 <oerjan> i think the last f equation is equivalent to f x y = church y (join (^)) (f x 0)
08:21:35 <oerjan> zzo38: i guessed that much
08:21:43 <oerjan> why not what
08:22:34 <oerjan> i am not sure whether combining church with (f $ pred x) can get you out of primitive recursive or not; nothing else there does
08:22:37 <zzo38> oerjan: O, yes, you are probably correct about the last f equation. I meant why not primitive recursive
08:23:38 <kallisti> oh....
08:23:41 <kallisti> I figured out what I want.
08:23:43 <kallisti> I think.
08:23:51 <kallisti> I think I want the StateT instance for MonadLogic?
08:24:09 <kallisti> assuming it works as I expect it to.
08:25:01 <kallisti> if I have StateT s [] a
08:25:10 <oerjan> ok so f x 0 = x ^ church x (\y -> church y (join (^)) (f (pred x) 0)) (x ^ x)
08:25:25 <oerjan> which is primitive recursive, i believe
08:25:27 <kallisti> then it should create a new state for each branch point, right?
08:25:33 <zzo38> oerjan: Yes which mean you don't really need the second argument
08:26:16 <oerjan> yep
08:26:31 <kallisti> :t runStateT
08:26:32 <lambdabot> forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
08:27:07 <oerjan> zzo38: so, as usual this would be smaller than ackermann stuff
08:27:12 <zzo38> Now what happen if the first argument to church is also decided using f?
08:28:35 <oerjan> zzo38: i doubt that helps; the problem is that it's too easy to split the part where y varies by itself, so you are really only recursing on one argument at a time
08:28:46 * kallisti is bad at monad transformers...
08:28:47 <oerjan> *split out
08:29:13 <zzo38> By using mostly only the f, church, join, exponent, and predecessor of its argument; possibly in a small way that still has a large effect
08:30:04 <zzo38> oerjan: Even if y is ignored though; and there is one argument x only; if you did that what happen?
08:30:51 <kallisti> > do { x <- get; lift [x+1,x-1] } >>- iterate succ
08:30:52 <lambdabot> Couldn't match expected type `t [] b' against inferred type `[s]'
08:31:29 <kallisti> halp
08:32:31 <kallisti> > evalStateT $ do { x <- get; lift [x+1,x-1] } >>- iterate succ
08:32:32 <lambdabot> Couldn't match expected type `Control.Monad.Trans.State.Lazy.StateT
08:32:32 <lambdabot> ...
08:34:22 <oerjan> zzo38: what would you use for church's second argument then? if you put f i don't think the recursion terminates.
08:36:10 <zzo38> oerjan: I know you can't put f... oops... maybe you need to use exponents and number by the predecessor of argument, too
08:38:47 <kallisti> > flip evalStateT 5 $ do { x <- get; lift [x+1,x-1] >>- (lift . iterate succ)}
08:38:51 <lambdabot> [6,4,7,5,8,6,9,7,10,8,11,9,12,10,13,11,14,12,15,13,16,14,17,15,18,16,19,17,...
08:38:58 <kallisti> I have no idea if this is doing what I want it to do.
08:39:24 <oerjan> i suspect ackermann's two arguments with f nested in the recursive rule is about the simplest you can do to get something out of primitive recursive territory
08:40:09 <kallisti> but it would seem reasonable that each alternative branch point in the [] instance of MonadLogic would have a distinct state...
08:40:16 <kallisti> rather than running the state linearly through the resulting list.
08:43:27 <kallisti> > interleave [1,2,3] [4,5,6]
08:43:28 <lambdabot> [1,4,2,5,3,6]
08:43:49 <oerjan> oh hm ack x y = ack (pred x) (ack x (pred y)) = church y (ack $ pred x) (ack x 0)
08:43:50 <kmc> it's a fun exercise to write "interleave" which works for an infinite number of infinite lists
08:43:57 <kallisti> > [1,2,3] >>- const [4,5,6]
08:43:58 <lambdabot> [4,4,5,4,6,5,5,6,6]
08:44:02 <kmc> or i guess it's 'transpose'
08:44:13 <oerjan> kmc: um isn't that what >>- does
08:44:30 <oerjan> well, (>>- id)
08:44:35 <kmc> likely
08:44:39 <kmc> is that from LogicT?
08:44:45 <kallisti> I've actually used (>>- id)
08:44:47 <oerjan> i think so
08:44:58 <kallisti> it's from the MonadLogic class specifically
08:45:03 <kmc> it's also what Control.Monad.Omega.diagonal does iirc
08:45:16 <kmc> but anyway you don't need to "um" me as I said it was an exercise
08:45:18 <zzo38> I did think of some variant of Ackermann-Peter function which include multiple application (by church) as well, such as: a 0 n = succ n; a m 0 = church (a (pred m) 1) (a $ pred m) 1; a m n = church (a (pred m) $ a m (pred n)) (a $ pred m) (a m $ pred n);
08:46:10 -!- Ngevd has joined.
08:46:17 <Ngevd> Hello!
08:46:33 <kallisti> > if [1,2,3] (\x -> [x,x,x]) undefined
08:46:34 <lambdabot> <no location info>: parse error (possibly incorrect indentation)
08:46:36 <kallisti> > ifte [1,2,3] (\x -> [x,x,x]) undefined
08:46:37 <lambdabot> [1,1,1,2,2,2,3,3,3]
08:46:49 <kallisti> > ifte [] (\x -> [x,x,x]) undefined
08:46:51 <lambdabot> *Exception: Prelude.undefined
08:47:00 <Ngevd> :t ifte
08:47:00 <lambdabot> forall (m :: * -> *) a b. (MonadLogic m) => m a -> (a -> m b) -> m b -> m b
08:47:59 <kallisti> Ngevd: I've been doing a lot of fancy magic since you left. :P
08:48:05 <Ngevd> Yay
08:48:09 <Ngevd> Magic that is fancy!
08:50:50 -!- _Slereah has quit (Ping timeout: 260 seconds).
08:53:02 <oerjan> so much better than boring magic!
08:55:06 <Ngevd> Also, kallisti, how do pawns behave with portals?
08:55:22 <oerjan> oh i think a category can be monoidal in more than one way, with product being one of them. makes more sense now.
08:56:13 <oerjan> i suppose the product is used for haskell, then
08:56:30 <oerjan> although you could also use Either instead...
08:56:43 <oerjan> (for the coproduct version)
08:56:45 <kallisti> Ngevd: as expected?
08:57:11 <zzo38> oerjan: Does that have anything to do with ArrowChoice?
08:57:18 <oerjan> zzo38: i expect so
08:57:43 <Ngevd> So, if there's a portal in front of them so they can go through it, and the matching portal is facing East, and they can move double, and move double through the portal, what happens?
08:58:37 <kallisti> the portal changes the direction of travel.
08:58:40 <kallisti> as though...
08:58:43 <kallisti> it were the same
08:58:44 <kallisti> >_>
08:58:49 <kallisti> as the original direction
08:58:51 <kallisti> or whatever.
08:58:54 <kallisti> this makes total sense.
08:58:55 <kallisti> :P
08:59:21 <zzo38> I did notice that how I have defined CatArrow, that ArrowChoice stuff is just done by CatArrow in a dual category with Either instead of (,)
09:00:51 <kallisti> Ngevd: think of it this way: portals just relocate points in a pieces moveset
09:01:06 <oerjan> hm that smash product example listed looks like what you would get if haskell's products were unlifted and you used bottoms as the identity. i think.
09:01:14 <kallisti> so that they continue in the direction forced by the out portal
09:01:33 <Ngevd> Hmm
09:01:36 <oerjan> (unlifted = (_|_, y) = (x, _|_) = _|_)
09:01:53 <oerjan> *unlifted means
09:02:00 <kallisti> Ngevd: this is a good way to think about it, because it's currently the way I'm implementing it. :>
09:03:55 <kallisti> Ngevd: btw I'll allow clients to request movesets
09:04:02 <kallisti> so a client can highlight possible moves for a piece
09:04:16 <kallisti> this should make reasoning about portals easier.
09:04:54 -!- _Slereah has joined.
09:09:08 <oerjan> zzo38: afaiu comonads are just monads in the dual category, so shouldn't coapplicatives be similarly related to applicatives? although i don't know the categorical definition of applicative.
09:10:30 <oerjan> `run echo "Comonads are just monads in the dual category." >wisdom/comonad
09:10:43 <HackEgo> No output.
09:10:53 <Ngevd> `? comonad
09:10:57 <HackEgo> Comonads are just monads in the dual category.
09:11:04 <Ngevd> Wow!
09:11:16 <Ngevd> Also, isn't that what `learn is for?
09:11:35 <oerjan> Ngevd: learn doesn't support pluralizing words afaik
09:11:54 <kallisti> > msplit [1,2,3,4]
09:11:55 <lambdabot> [Just (1,[2,3,4])]
09:12:01 <kallisti> ah
09:12:16 <oerjan> it does at least convert to lowercase.
09:12:30 <oerjan> `cat bin/learn
09:12:33 <HackEgo> ​#!/bin/sh \ topic=$(echo "$1" | sed 's/ .*//' | tr A-Z a-z) \ info=$(echo "$1" | sed 's/[^ ]* //') \ echo "$1" >"wisdom/$topic" \ echo "I knew that." \
09:14:12 <oerjan> msplit looks like it would be useful for pointlessing
09:14:27 <oerjan> oh wait it has a surrounding []
09:14:31 <oerjan> :t msplit
09:14:32 <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m (Maybe (a, m a))
09:14:43 <kallisti> > iterate (>>- iterate succ) 0
09:14:44 <lambdabot> No instance for (GHC.Num.Num [a])
09:14:44 <lambdabot> arising from a use of `e_10' at <inter...
09:14:48 <kallisti> > iterate (>>- iterate succ) [0]
09:14:49 <lambdabot> [[0],[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,2...
09:28:42 -!- Ngevd has quit (Ping timeout: 245 seconds).
09:31:24 <kallisti> > sequence [[1..], [0..]]
09:31:25 <lambdabot> [[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],[1,10],[1,11],...
09:31:54 <kallisti> :t iterate
09:31:55 <lambdabot> forall a. (a -> a) -> a -> [a]
09:32:03 <kallisti> @hoogle (a -> a) -> a -> m a
09:32:04 <lambdabot> Prelude iterate :: (a -> a) -> a -> [a]
09:32:04 <lambdabot> Data.List iterate :: (a -> a) -> a -> [a]
09:32:04 <lambdabot> Data.Generics.Schemes everywhere :: (forall a. Data a => a -> a) -> (forall a. Data a => a -> a)
09:32:15 <kallisti> @hoogle (Monad m) => (a -> a) -> a -> m a
09:32:16 <lambdabot> Prelude iterate :: (a -> a) -> a -> [a]
09:32:16 <lambdabot> Data.List iterate :: (a -> a) -> a -> [a]
09:32:16 <lambdabot> Data.Generics.Schemes everywhere :: (forall a. Data a => a -> a) -> (forall a. Data a => a -> a)
09:38:57 -!- Ngevd has joined.
09:46:13 <zzo38> oerjan: I know comonads are just monads in the dual category. But I don't know of coapplicatives
09:46:23 -!- zzo38 has quit (Remote host closed the connection).
10:03:48 <oerjan> :t \(x,y) -> (,) x `liftM` y
10:03:49 <lambdabot> forall t a1 (m :: * -> *). (Monad m) => (t, m a1) -> m (t, a1)
10:04:15 <oerjan> i assume that's the strong monad strength function
10:05:43 <oerjan> :t either (return.Left) (liftM Right)
10:05:44 <lambdabot> forall (m :: * -> *) a a1. (Monad m) => Either a (m a1) -> m (Either a a1)
10:06:02 <oerjan> and that would be another candidate for the coproduct monoid
10:21:37 <kallisti> @hoogle (MonadPlus m) => m a -> Bool
10:21:38 <lambdabot> Data.IntMap null :: IntMap a -> Bool
10:21:38 <lambdabot> Data.Maybe isJust :: Maybe a -> Bool
10:21:38 <lambdabot> Data.Maybe isNothing :: Maybe a -> Bool
10:22:14 <kallisti> @hoogle mconcat
10:22:15 <lambdabot> Data.Monoid mconcat :: Monoid a => [a] -> a
10:22:26 -!- myndzi has quit (Ping timeout: 248 seconds).
10:22:35 <Ngevd> :t (== mzero)
10:22:35 <lambdabot> forall (m :: * -> *) a. (MonadPlus m, Eq (m a)) => m a -> Bool
10:23:47 <kallisti> > [1,2,3] >> []
10:23:48 <lambdabot> []
10:25:56 <kallisti> > msum (repeat [])
10:26:00 <lambdabot> mueval-core: Time limit exceeded
10:28:36 <oerjan> > msum []
10:28:37 <lambdabot> No instance for (GHC.Show.Show (m a))
10:28:37 <lambdabot> arising from a use of `M6822796534...
10:30:37 <kallisti> > Nothing `mplus` Just 2
10:30:38 <lambdabot> Just 2
10:31:14 <Ngevd> > Just 1 `mplus` Just 2
10:31:15 <lambdabot> Just 1
10:32:54 -!- sebbu has quit (Ping timeout: 255 seconds).
10:39:47 -!- monqy has quit (Quit: hello).
10:47:52 -!- Frooxius has quit (Ping timeout: 245 seconds).
10:57:12 -!- KingOfKarlsruhe has joined.
11:09:33 -!- Frooxius has joined.
11:10:04 -!- Frooxius has quit (Read error: Connection reset by peer).
11:11:22 -!- Frooxius has joined.
11:12:15 -!- Frooxius has quit (Client Quit).
11:14:55 -!- Frooxius has joined.
11:18:21 -!- Frooxius has quit (Read error: Connection reset by peer).
11:20:24 -!- Frooxius has joined.
11:20:39 <oerjan> spaamius
11:41:37 -!- Frooxius has quit (Ping timeout: 240 seconds).
11:49:54 -!- kallisti has quit (Ping timeout: 248 seconds).
11:51:07 -!- Ngevd has quit (Ping timeout: 252 seconds).
11:54:57 -!- Ngevd has joined.
11:56:07 <Ngevd> I reckon DMM is dying
11:56:12 -!- Frooxius has joined.
11:56:25 <Ngevd> And wants to pass all his knowledge onto the next generation
11:58:13 -!- Ngevd has quit (Client Quit).
12:09:53 -!- Ngevd has joined.
12:09:59 -!- Frooxius has quit (Read error: Connection reset by peer).
12:11:06 -!- Frooxius has joined.
12:14:26 -!- leonid[sunp] has joined.
12:14:31 <leonid[sunp]> helo
12:15:34 <Ngevd> Hello
12:15:37 <Ngevd> `welcome
12:15:40 <HackEgo> Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: http://esolangs.org/wiki/Main_Page
12:15:50 <leonid[sunp]> i've been looking at fernando language
12:16:08 <leonid[sunp]> and wondered if it is possible to build a program that outputs the shortest possible fernando code that outputs any given string
12:16:38 <Ngevd> Definitely
12:17:44 <Ngevd> Efficiently is another challenge altogether
12:21:16 <oerjan> excuse me, but if fernando is turing-complete, that is impossible.
12:21:50 <oerjan> see kolmogorov complexity.
12:22:13 <leonid[sunp]> i see.
12:22:34 <fizzie> oerjan: How so? Enumerate through programs in shortlex order, for each program: ask your neighbourhood Turing oracle whether it halts, if it doesn't run it, if it outputted the string you wanted, well, there it is.
12:22:51 <leonid[sunp]> iirc, fernando doesn't have input function.
12:23:00 * oerjan swats fizzie -----###
12:23:28 <fizzie> oerjan: I don't think FerNANDo has any sort of unbounded storage, though.
12:23:59 <Ngevd> FerNANDo is linear bounded
12:25:51 <leonid[sunp]> it's basically a matter of detecting a pattern from the desired output
12:26:23 <oerjan> ah, maybe so then.
12:27:13 <oerjan> yes, then just simulate and check for repetition to throw out non-halting programs.
12:33:00 <leonid[sunp]> not sure how to approach this
12:33:17 <oerjan> it's still not efficient though.
12:33:32 <leonid[sunp]> i gave up getting the optimal code
12:33:46 <leonid[sunp]> 'fairly good' ones will satisfy me
12:36:10 <oerjan> well it's easy to make one which uses 3+8*n commands where n is the number of bits in the string.
12:36:43 <leonid[sunp]> haha yeah
12:36:51 <leonid[sunp]> i'd say that one is the upper bound
12:37:51 <oerjan> and loops are hard to use. especially since you can only jump backwards.
12:39:15 <leonid[sunp]> also wondering if it's possible to make fernando quine
12:41:09 <leonid[sunp]> (except for the trivial 0b solution of course)
12:41:29 <leonid[sunp]> actually nevermind. an empty code will cause an error
12:42:00 <Ngevd> I don't see anything stopping it
12:43:05 <oerjan> i don't know why it would be an error.
12:43:42 <leonid[sunp]> i thought the only valid lines of codes are those that consist of 1, 3, or 8 variables
12:43:50 <leonid[sunp]> looks like i'm wrong
12:44:22 <oerjan> yes, what does that have to do with having _no_ lines?
12:45:47 <leonid[sunp]> i see
12:46:38 <leonid[sunp]> forget the part where i said 'nevermind'
12:46:48 <oerjan> forget what?
12:46:59 <leonid[sunp]> forget this line [07:41:15] <leonid[sunp]> actually nevermind. an empty code will cause an error
12:47:12 <oerjan> oh, thanks for reminding me.
12:47:38 <oerjan> i'm not sure how you'd organize a quine in this.
12:49:32 <oerjan> for the main reason that i'm not sure how do structured data of comparable size to the program itself.
12:50:22 <oerjan> *to do
13:04:48 -!- hagb4rd has quit (Read error: Connection reset by peer).
13:05:42 -!- hagb4rd has joined.
13:12:16 -!- Frooxius has quit (Ping timeout: 252 seconds).
13:14:49 <Ngevd> I'm worried.
13:14:56 <Ngevd> My dog just threw me a ball
13:16:53 -!- Frooxius has joined.
13:17:36 <oerjan> well did you fetch properly?
13:21:45 <oklopol> i saw a cat throw a ball at another cat's face yesterday
13:22:07 <olsner> Ngevd: you're the dog now man
13:22:47 -!- oerjan has quit (Quit: Good boy!).
13:33:25 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
13:34:57 -!- Ngevd has quit (Ping timeout: 245 seconds).
13:37:44 -!- Ngevd has joined.
13:37:52 -!- Frooxius has quit (Ping timeout: 252 seconds).
13:38:12 -!- Ngevd has quit (Client Quit).
14:02:46 -!- sebbu has joined.
14:02:47 -!- sebbu has quit (Changing host).
14:02:47 -!- sebbu has joined.
14:14:20 -!- KingOfKarlsruhe has quit (Quit: ChatZilla 0.9.88 [Firefox 9.0.1/20111220165912]).
14:33:24 -!- sebbu has quit (Read error: Connection reset by peer).
14:33:49 -!- sebbu has joined.
14:33:49 -!- sebbu has quit (Changing host).
14:33:49 -!- sebbu has joined.
14:48:23 -!- MSleep has changed nick to MDude.
14:58:20 -!- Ngevd has joined.
14:58:25 <Ngevd> Hello
15:13:30 <kmc> hi Ngevd
15:15:23 <Ngevd> We're in the future
15:16:21 <fizzie> How did you get there?
15:17:03 <Ngevd> By waiting
15:17:13 <Ngevd> But now we're in the past...
15:17:15 <fizzie> Sounds complicated.
15:28:07 -!- Frooxius has joined.
15:39:51 -!- Ngevd has quit (Quit: Goodbye).
15:44:39 -!- primo has joined.
15:47:12 -!- azaq23 has joined.
15:47:21 -!- azaq23 has quit (Max SendQ exceeded).
15:48:02 -!- azaq23 has joined.
16:13:06 -!- MDude has quit (Ping timeout: 255 seconds).
16:34:18 <Phantom_Hoover> @tell elliott Oh god why are rabbits so tasty im crisis
16:34:18 <lambdabot> Consider it noted.
16:48:18 <Sgeo> Phantom_Hoover, what makes you think elliott is coming back?
16:48:27 <Sgeo> Oh, I guess he can receive the message in #haksell
16:48:29 <Sgeo> #haskell
16:49:08 <fizzie> #haxhell.
16:52:29 -!- primo has quit (Ping timeout: 240 seconds).
16:54:25 -!- Phantom_Hoover has quit (Remote host closed the connection).
17:18:39 -!- ais523 has joined.
17:40:10 <fizzie> Just a heads-up, but the robotic uprising has started: http://users.ics.tkk.fi/htkallas/roombastruction.jpg
17:40:51 <fizzie> First they cut the cellphone chargers; next, our necks.
17:41:17 <fizzie> (Even the microUSB connector has been sliced, not just the cable.)
17:54:32 -!- Ngevd has joined.
17:55:04 <Ngevd> Hello
17:58:11 <Ngevd> fwehfiuwehfui
17:58:14 <Ngevd> fungot
17:58:14 <fungot> Ngevd: i could point you in the us a jelly donut. i am sure it can
17:58:21 <Ngevd> ^style
17:58:21 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher fungot homestuck ic irc* iwcs jargon lovecraft nethack pa qwantz sms speeches ss wp youtube
17:58:31 <Ngevd> ^style ss
17:58:31 <fungot> Selected style: ss (Shakespeare's writings)
17:58:41 <Ngevd> fungot, fwehfiuwehfui
17:58:41 <fungot> Ngevd: pro. as manie as you please.
17:58:52 <Ngevd> What a dude.
17:59:48 <fizzie> fungot: Are you in league with the Roombalords?
17:59:49 <fungot> fizzie: widdow. it quakes me too, now i understand ye very well: could he say lesse
18:00:17 <fizzie> I'm not sure if that's a yes or a no.
18:00:46 <Ngevd> Truly, fungot is a master of trickery.
18:00:46 <fungot> Ngevd: gon. let your study be to content your lord, that fault is none of my lords meat? then they could smile and fawn upon his debts, and take leaue. i am
18:01:01 <Ngevd> fizzie, how hard is it to add a style?
18:01:13 <fizzie> Ngevd: It's not entirely automated, but not very hard.
18:01:49 <fizzie> You basically need a datafile of what you want it to say in "one sentence per line" plaintext format.
18:03:27 <fizzie> Then it's just a matter of some ./preprocess.pl sed -e 's#.*#<s> & </s>#' varikn-1.0.2/varigram_kn -o .. -D .. -E .. -C -3 -n .. .. -a .. ./arpa2fungot.pl and there it is.
18:03:28 <fungot> fizzie: first lord. go, comfort your bed, with hey the sweet birds throte: come hither
18:03:52 <fizzie> With suitable ..s.
18:06:10 <Ngevd> I am writing a program and have no way to check it for errors
18:06:27 <fizzie> So you thought a new fungot style might help? Makes sense.
18:06:27 <fungot> fizzie: she fals the sword. send succours ( lords) to let you enter his vnpeopled house. enter. mes. so like you, sir. nicholas and frailty, as men you are in hast: and speed must answer it
18:06:37 <Ngevd> Take my mind of things
18:06:46 <Ngevd> With a bit of automated Oscar Wilde
18:09:00 <fizzie> I've got 14322 sentences of that stuff at the moment, it seems.
18:09:20 <fizzie> I suppose it would be possible to stylify that. It's just a bit of a bother.
18:14:16 -!- cheater has quit (Ping timeout: 244 seconds).
18:19:55 -!- MDude has joined.
18:23:05 <Sgeo> Is fungot's source available? I want to try running fungot in another channel.
18:23:06 <fungot> Sgeo: fra. you louing men of angiers open wide your gates and let young arthur, duke of clarence daughter, did he tempt thee so? her. they give their greeting to the senators let me desire to know wherefore i sent, and your fnord, your ques, and your increasing in love leonatus posthumus.'
18:29:05 <ais523> ^source
18:29:05 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
18:29:07 <ais523> Sgeo: ^
18:29:26 <fizzie> That's actually slightly misleading.
18:29:44 <Sgeo> What about all the styles? Are they available somewhere?
18:29:58 <fizzie> But you can find all the necessary bits from behind that link, you just need more than just fungot.b98.
18:29:59 <fungot> fizzie: mon. how? bribe me? is it? cel. i warrant you
18:30:02 <Ngevd> Or could we just get a multichannel fungot
18:30:03 <fungot> Ngevd: captain. pray, at whose suit is this? ham. to be hang'd that wilt not stay her tongue. the fnord
18:30:25 <Ngevd> It works for msg
18:30:32 <fizzie> The current fungot works well enough multichannel, yes.
18:30:33 <fungot> fizzie: gloster. now, sirs, be careful of your own will. is he not with the dolphins grace, his new-come champion, vertuous ioane of acre, nor any man of qualitie: i hope this reason stands for my bountie: but who is here?
18:30:39 <fizzie> And the styles aren't anywhere.
18:30:43 <fizzie> They're quite big, anyway.
18:30:59 <fizzie> My fungot directory is ~630M.
18:31:00 <Sgeo> Aww, ok
18:31:00 <fungot> fizzie: sil. what sai'st thou boy? i loue, and thou, and nature must obey necessitie, which we, on like conditions, will have it so, to great and high estate. is left to tyrannize upon my breast; and, when your owne percy, when my father dyed within's two houres
18:31:05 <Ngevd> Sgeo, tell fizzie what channels you wanted
18:31:11 <Ngevd> fizzie, work magic for Sgeo
18:31:23 <fizzie> Most of them are from public sources, anyway, so you can build them.
18:31:38 <fizzie> And the ones that aren't I probably couldn't share either.
18:31:40 <fizzie> ^style fisher
18:31:40 <fungot> Selected style: fisher (Fisher corpus of transcribed telephone conversations)
18:31:42 <fizzie> Like this one.
18:31:48 <fizzie> I think it's got some copyrights on it.
18:31:59 <Sgeo> o.O how did you get it?
18:32:11 <Sgeo> fungot, then who was phone?
18:32:11 <fungot> Sgeo: so you know getting your opinion on that how can anything that)) i've ( ( wanted to go to florida for the summer
18:32:12 <fizzie> You can buy it with $1000 from LDC, apparently.
18:32:23 <fizzie> Well, "Part 1" transcripts, anyway.
18:32:28 <fizzie> I'm not quite sure what I used.
18:32:52 <fizzie> The extra ()s are something I forgot to clean up, it's got this annotation thing going on.
18:34:08 <fizzie> Also I got it since we have that sort of stuff at work, and I thought building a model and spewing some output now and then will fall under the "negligible amounts" rules, or whatever.
18:37:04 -!- kallisti has joined.
18:37:04 -!- kallisti has quit (Client Quit).
18:37:15 -!- kallisti has joined.
18:39:10 -!- Ngevd has quit (Quit: Goodbye).
18:45:57 -!- zzo38 has joined.
18:50:58 <Sgeo> annotation thing?
18:52:04 <Sgeo> ^styles
18:52:08 <Sgeo> ^style
18:52:08 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher* fungot homestuck ic irc iwcs jargon lovecraft nethack pa qwantz sms speeches ss wp youtube
18:52:16 <Sgeo> ss?
18:52:20 <Sgeo> ct?
18:52:27 <Sgeo> ic?
18:52:30 <Sgeo> pa?
18:52:50 <fizzie> Shapespeare, Chrono Trigger, INTERCAL, Penny Arcade. (From memory.)
18:52:56 <Sgeo> Ah
18:52:56 <fizzie> Just try them and look at the descriptions.
18:52:58 <fizzie> ^style ss
18:52:58 <fungot> Selected style: ss (Shakespeare's writings)
18:53:00 <fizzie> ^style ct
18:53:01 <fungot> Selected style: ct (Chrono Trigger game script)
18:53:02 <fizzie> ^style ic
18:53:03 <fungot> Selected style: ic (INTERCAL manual)
18:53:04 <fizzie> ^style pa
18:53:04 <fungot> Selected style: pa (around 1200 transcribed Penny Arcade comics)
18:53:04 <Sgeo> Oh, ok
18:53:14 <Sgeo> ^style sms
18:53:14 <fungot> Selected style: sms (National University of Singapore SMS corpus, 2011-08-20)
18:53:25 <fizzie> fungot: What's bubbling, mon?
18:53:26 <fungot> fizzie: wat.? abt the imp. at one? if dun go dunno. i generally free since school holiday. are u okay with any guy...after u told to give xerox wen vil u cum? on you or in you. psalm.. ezek.. 2peter decimal. 1peter 5
18:53:36 <Sgeo> Why does the National University of Singapore have an SMS corpus?
18:53:42 <Sgeo> ^style c64
18:53:42 <fungot> Selected style: c64 (C64 programming material)
18:53:48 <Sgeo> ^style irc
18:53:48 <fungot> Selected style: irc (IRC logs of freenode/#esoteric, freenode/#scheme and ircnet/#douglasadams)
18:53:49 <fizzie> Why does the National University of Singapore do anything, really?
18:54:11 <Sgeo> I mean, how does a university get access to SMS messages like that?
18:54:36 <fizzie> They asked people.
18:54:45 <fizzie> That one was more explicit than they usually are, though.
18:54:57 <zzo38> In my opinion, the many-worlds interpretation of quantum mechanics is as good as any other. So you might need different interpretation for different purposes
18:55:29 <Sgeo> purposes?
18:55:35 <fizzie> "These messages were collected from volunteers who were made aware that their contributions were going to be made publicly available."
18:56:00 <fizzie> They're still collecting it, incidentally.
18:56:25 <fizzie> "As of January 2012 , we have collected 41208 English SMS messages (exclusive the old corpus) and 29381 Chinese SMS messages ."
18:56:35 <fizzie> They also put spaces in front of commas and periods, I see.
18:56:49 <fizzie> Anyway, the 2011-08-20 copy had... maybe 20-30k messages?
19:03:42 -!- Klisz has joined.
19:04:34 -!- Ngevd has joined.
19:04:52 <Ngevd> Hello
19:05:14 <Ngevd> fizzie, I've began formatting OW's plays into fungot-format
19:05:15 <fungot> Ngevd: the vm or elsewhere. then just ( set! stream... oh well. if it does it's what littledan asked about.
19:05:34 <fizzie> Ngevd: I've got them in sort-of the right format already.
19:05:54 <Ngevd> Oh, cool
19:06:03 <fizzie> http://p.zem.fi/vz5c -- well, these ones, anyway.
19:07:12 <Ngevd> Shall I do Salome?
19:07:38 <zzo38> Add the style for Super ASCII MZX Town (probably too small data for a meaningful program, however)
19:08:07 <zzo38> So add other stuff such as the wiki article for the game
19:08:22 <zzo38> And other people comments if they complained and so on
19:08:34 <zzo38> Is probably still too small data
19:13:38 <fizzie> The smallest styles which I have in there are probably around 2000-3000 lines. The YouTube one might've been smaller than that. Anyway, I'm remarkably lazy when it comes to actually adding new styles.
19:18:50 <zzo38> I have only 813 lines (31126 bytes) so it is insufficient
19:19:22 <Ngevd> ASCII MZX Town?
19:20:21 <zzo38> It is a computer game series that I have made. Part I is already complete. Part II is not complete so you cannot play the Part II game yet.
19:22:20 -!- oerjan has joined.
19:29:34 <kallisti> walk :: (MonadLogic m) => WalkRule m -> Board -> Move -> m Move
19:29:34 <kallisti> walk rule b = msum . iterate (>>- step rule b) . step rule b
19:29:39 <kallisti> if I understand this correctly
19:29:47 <kallisti> this won't terminate
19:30:00 <kallisti> because eventually it will begin iterating an infinite list of []'s
19:30:10 <kallisti> or
19:30:12 <kallisti> mzeros actually
19:30:57 <kallisti> > iterate (>>- const []) []
19:30:58 <lambdabot> [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]...
19:30:59 <oerjan> iterate always gives an infinite list
19:31:01 <kallisti> yes like that
19:31:07 <kallisti> > msum $ iterate (>>- const []) []
19:31:09 <kallisti> :(
19:31:11 <lambdabot> mueval-core: Time limit exceeded
19:31:16 <kallisti> > msum $ iterate (>>- const []) [1]
19:31:19 <lambdabot> mueval-core: Time limit exceeded
19:31:20 <kallisti> :(((((((((((((((((((((((
19:31:24 <kallisti> damn you halting problem.
19:31:34 <kallisti> so the question is: how many MonadPlus instances are always Eq instances?
19:31:42 <kallisti> because I need to check for mzero
19:32:10 <oerjan> very few, i should imagine
19:32:17 <kallisti> hm
19:32:36 <oerjan> since you'd usually need Eq x for Eq (m x)
19:33:09 <oerjan> :t ifte
19:33:10 <lambdabot> forall (m :: * -> *) a b. (MonadLogic m) => m a -> (a -> m b) -> m b -> m b
19:33:18 <oerjan> isn't that what this does?
19:33:24 <kallisti> oh
19:33:33 <kallisti> well......
19:33:54 <kallisti> yes
19:33:59 <oerjan> > ifte [1,2] return [3,4]
19:34:00 <lambdabot> [1,2]
19:34:17 <kallisti> I could recursively call that I think
19:34:22 <kallisti> but I always want to accumulate a list.
19:35:04 <kallisti> hm
19:35:42 <kallisti> so I'll just wrap it in a Maybe
19:35:45 <kallisti> and check for Nothing
19:35:50 <kallisti> perhaps
19:35:54 <kallisti> I'll see if there's a better way.
19:36:15 <kallisti> oh I can't wrap it in Maybe
19:37:04 <kallisti> oh... I know
19:38:20 <kallisti> walk :: (MonadLogic m) => WalkRule m -> Board -> Move -> m Move
19:38:21 <kallisti> walk rule b m = ifte (step rule b m) (walk rule b) (return m)
19:38:31 <kallisti> I think.
19:40:16 <kallisti> so now I can use StateT [] or just [] or any other MonadLogic
19:40:19 <kallisti> which is excellent.
19:43:04 <kallisti> I'm kind of surprised that Maybe isn't a MonadLogic.
19:43:10 <kallisti> maybe it doesn't satisfy some law.
19:44:24 <zzo38> There is no definition for msplit for Maybe
19:44:26 <Vorpal> hi
19:44:36 <zzo38> That is why it doesn't work
19:44:39 <kallisti> zzo38: ah indeed
19:44:55 <oerjan> :t msplit
19:44:56 <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m (Maybe (a, m a))
19:46:00 <oerjan> :t let msplit x = flip (,) Nothing <$> x in msplit
19:46:02 <lambdabot> forall (f :: * -> *) a a1. (Functor f) => f a -> f (a, Maybe a1)
19:46:16 <oerjan> um hm
19:46:55 <kallisti> I believe it has to satisfy some laws as well. :P
19:47:09 <kallisti> I wonder if at patterns work with record puns....
19:47:17 <kallisti> pun@(Con a b c)
19:48:06 <kallisti> I don't think it would
19:48:12 -!- monqy has joined.
19:48:16 <Ngevd> :t Con
19:48:17 <lambdabot> Not in scope: data constructor `Con'
19:48:32 <oerjan> msplit mzero == return Nothing msplit (return a `mplus` m) == return (Just (a, m))
19:49:32 <oerjan> msplit Nothing = Just Nothing; msplit (Just a) = Just (Just (a, ...))
19:50:01 <oerjan> i see, the problem is that m is discarded
19:52:38 <fizzie> Ooh, the progressivest: we just (very likely) voted a gay man to the second round (top two candidates) of the Finnish presidential elections. Though I really don't think the gayness had much to do with it. Still, one could have thought that would have been off-putting to some.
19:53:14 <Deewiant> You'll see just how off-putting it is when he gets around 30% of the votes in the second round.
19:53:30 <fizzie> There is that.
19:54:37 <fizzie> I'm not so sure Paavo #1 would do *that* much better, though who knows.
19:55:04 <fizzie> There are altogether too many Paavos in this election.
19:55:11 <Deewiant> Heh, true.
19:55:55 <oerjan> hm has anyone gay been directly voted to a top position anywhere in the world - the icelandic prime minister was presumably selected by parliament, not directly
19:56:17 <fizzie> (37.5% of the candidates have the given name Paavo, for the non-.fi followers.)
19:56:28 <Deewiant> But I guess the Soini + Essayah votes will probably all go to Niinistö directly, whereas with Väyrynen that'd be different
19:57:05 <oerjan> and she was supposedly the first to reach that point
20:00:43 <fizzie> oerjan: There's the prime minister of Belgium, presumably with the same caveats. And I think there was an almost-President somewhere, was #2 in an election with a not too large gap.
20:00:54 <oerjan> oh right
20:04:54 <fizzie> http://en.wikipedia.org/wiki/David_Norris_(politician) is probably what I was thinking of, except seems it was more complicated than that.
20:13:01 <Ngevd> Hmm
20:13:38 <Ngevd> A Piet program could be represented as a graph where nodes have two values: colour and size
20:13:50 <Ngevd> It would be directed and non-simple
20:13:56 <Ngevd> But continuous?
20:14:41 <Ngevd> Each node would have an outdegree of 8
20:15:54 <Ngevd> Blocked outs would go to itself?
20:16:47 <fizzie> Given that blocked outs just twiddle those pointer things, they might also go wherever they go.
20:16:58 -!- Phantom_Hoover has joined.
20:17:02 <Ngevd> Of course, this assumes the out-arcs are ordered
20:17:11 <fizzie> Some Piet compilers probably produce a graph representation. I think my halfway-done llpiet did.
20:17:27 -!- MDude has quit (Ping timeout: 255 seconds).
20:17:41 <fizzie> If I'm not mistaken, it could also write it out as a dot file.
20:18:55 <zzo38> I made up a list of monster age category for D&D 3.5e game; it is incomplete but is good enough to make up the age of my and my brother's character
20:20:05 <zzo38> And possibly even a few non-player characters we might find, if necessary to figure out their age
20:20:26 -!- oerjan has quit (Quit: Good night).
20:20:44 -!- MDude has joined.
20:20:56 -!- TeruFSX has quit (Disconnected by services).
20:22:12 -!- TeruFSX_ has joined.
20:22:56 -!- oklopol has quit (Ping timeout: 244 seconds).
20:29:52 <kallisti> walk rule b m = ifte (step rule b m) (walk rule b) (return m)
20:29:56 <kallisti> I don't think this is what I want actually
20:30:56 <kallisti> :t reflect
20:30:57 <lambdabot> forall a (m :: * -> *). (MonadLogic m) => Maybe (a, m a) -> m a
20:31:13 <kallisti> I think I need to use this to "accumulate" a "list"
20:31:31 <Sgeo> :t ifte
20:31:32 <lambdabot> forall (m :: * -> *) a b. (MonadLogic m) => m a -> (a -> m b) -> m b -> m b
20:31:34 <kallisti> > reflect Nothing :: [Int[
20:31:35 <lambdabot> <no location info>: parse error (possibly incorrect indentation)
20:31:36 <kallisti> > reflect Nothing :: [Int]
20:31:36 <lambdabot> []
20:31:44 <kallisti> yeah
20:32:06 <kallisti> not sure why it's called reflect though
20:32:25 -!- Taneb has joined.
20:32:31 <Sgeo> What is reflect? Something with LogicT?
20:33:04 <kallisti> something with MonadLogic yes.
20:33:08 <kallisti> it's the inverse of msplit
20:33:16 <kallisti> > msplit [1,2,3]
20:33:16 <lambdabot> [Just (1,[2,3])]
20:33:39 <kallisti> > reflect (Just (1, [2,3]))
20:33:40 <lambdabot> [1,2,3]
20:33:43 <kallisti> well, almost inverse
20:36:08 -!- Ngevd has quit (Ping timeout: 276 seconds).
20:36:09 <kallisti> walk :: (MonadLogic m) => WalkRule m -> Board -> Move -> m Move
20:36:09 <kallisti> walk rule b m = ifte (step' m) iterateSteps (return m)
20:36:09 <kallisti> where
20:36:09 <kallisti> iterateSteps m' = reflect $ Just (oneStep, walk rule b m')
20:36:13 <kallisti> ....I think this is it.
20:36:23 <Taneb> Hang on
20:36:26 <Taneb> When did I lag out
20:36:46 <kallisti> ?
20:36:54 <Taneb> Between "I think I need to use this to "accumulate" a "list"" and "What is reflect? Something with LogicT?"
20:37:24 <kallisti> Taneb: http://codu.org/logs/log/_esoteric/s
20:37:53 <monqy> logreading in stalker mode "a good idea"
20:38:07 <kallisti> monqy: yes to figure out what happened in a disconnect it's pretty ideal.
20:38:12 <Taneb> Ah, I didn't miss much
20:41:06 -!- DCliche has joined.
20:42:30 -!- Darth_Cliche has joined.
20:43:12 <Taneb> So...
20:44:33 -!- Klisz has quit (Ping timeout: 245 seconds).
20:45:43 <Taneb> Esolang idea!
20:45:48 <Taneb> brb
20:45:49 <lambdabot> Taneb: You have 1 new message. '/msg lambdabot @messages' to read it.
20:46:09 -!- DCliche has quit (Ping timeout: 252 seconds).
20:52:06 <kallisti> walk :: (MonadLogic m) => WalkRule m -> Board -> Move -> m Move
20:52:06 <kallisti> walk rule b m = oneStep `mplus` ifte oneStep (walk rule b) mzero where oneStep = step' m
20:52:10 <kallisti> ....I know I've said this a lot
20:52:13 <Taneb> back
20:52:14 <kallisti> but I think this is the one I want.
20:52:26 <Taneb> So, esolang idea!
20:52:35 <Taneb> Continuous liquid automaton!
20:52:41 <kallisti> oh my
20:53:04 <kallisti> sounds interesting
20:53:41 <kallisti> > [1,2,3] `mplus` [4,5,6]
20:53:42 <lambdabot> [1,2,3,4,5,6]
20:53:47 <kallisti> shocking
20:53:53 <kallisti> all the list monoids do the same thing
20:55:33 <zzo38> That is really the only thing for Alternative and MonadPlus to do; Monoid could have been designed to do something different but instead it doesn't different, but concatenation is probably a useful way anyways so they don't need to change that
20:56:26 <kallisti> oh I just realized that ifte m f mzero
20:56:28 <kallisti> is just....
20:56:31 <kallisti> m >>- f
20:56:36 <kallisti> I believe
21:00:28 <monqy> > [1, 2, 3] >>- replicate 2
21:00:28 <lambdabot> [1,2,1,3,2,3]
21:00:34 <monqy> > ifte [1, 2, 3] (replicate 2) mzero
21:00:34 <lambdabot> [1,1,2,2,3,3]
21:00:46 <kallisti> oh
21:01:03 <kallisti> so.... >>- is better? :
21:01:08 <kallisti> for infiniteness
21:01:10 <kallisti> as usual.
21:01:32 <Sgeo> :t (>>-)
21:01:33 <lambdabot> forall (m :: * -> *) a b. (MonadLogic m) => m a -> (a -> m b) -> m b
21:01:53 <kallisti> > Just 2 `mplus` Nothing
21:01:54 <lambdabot> Just 2
21:02:03 <kallisti> > Just 2 `mplus` Just 3 `mplus` Nothing
21:02:04 <lambdabot> Just 2
21:02:04 <Sgeo> > Just 2 `mplus` Just 3
21:02:05 <lambdabot> Just 2
21:02:08 <kallisti> > Nothing `mplus` Just 3 `mplus` Nothing
21:02:09 <Sgeo> > Just 2 `mappend` Just 3
21:02:09 <lambdabot> Just 3
21:02:10 <lambdabot> Ambiguous type variable `t' in the constraints:
21:02:10 <lambdabot> `Data.Monoid.Monoid t'
21:02:10 <lambdabot> ...
21:02:12 <kallisti> okay same as <|>
21:02:13 <Sgeo> ...?
21:03:10 <kallisti> hm
21:03:35 <Taneb> Time to watch Megashark vs Crocosaurus
21:07:36 -!- ion has joined.
21:08:09 -!- Scriptor has joined.
21:22:57 -!- Darth_Cliche has quit (Read error: Connection reset by peer).
21:23:23 -!- Darth_Cliche has joined.
21:28:35 <kallisti> bah, using liftM instead of <$> to remove a Functor dependency feels....
21:28:37 <kallisti> wrong
21:29:03 <zzo38> kallisti: I agree. Monad should always have a Functor dependency
21:29:25 <Deewiant> Let (<#>) = liftM
21:30:19 <Taneb> Phantom_Hoover, guess what!
21:30:38 <kallisti> Taneb: http://sprunge.us/dZbj
21:30:51 <kallisti> everything in comments is currently broken, everything else at least compiles
21:31:29 <kallisti> types: http://sprunge.us/hFcT
21:31:30 <Phantom_Hoover> Taneb, OH GOD IS EVERYONE DEAD
21:31:38 <Phantom_Hoover> AM I IN HEXHAM
21:31:39 <Taneb> Phantom_Hoover, even worse!
21:31:41 <Phantom_Hoover> IS HEXHAM EDINBURGH
21:31:55 <Taneb> Your Pixelquest suggestion will be in the next update
21:31:55 <Taneb> !
21:32:06 <Phantom_Hoover> nooooooooooooo
21:33:43 <Taneb> Goodnight
21:33:45 -!- Taneb has quit (Quit: Goodbye).
21:34:03 <kallisti> Taneb: what's awesome about MonadLogic is that it has an instance for both lists and (MonadLogic m) StateT s m
21:34:13 <kallisti> so... I can write walk rules that keep track of state.
21:34:48 <kallisti> as well as walkrules that require no state but will still work if state is used.
21:36:03 <kallisti> walkWith forwardStep (followPortals `orRule` stopAtPiece)
21:36:10 -!- Darth_Cliche has changed nick to Klisz.
21:36:11 <kallisti> walk = walkWith forwardStep
21:36:44 <kallisti> what's good about all of this
21:36:52 <kallisti> is that changing the rules in the future /should/ be easier.
21:38:07 <kallisti> > [1,2,3] <*> []
21:38:08 <lambdabot> []
21:38:17 <kallisti> hm
21:38:32 <kallisti> > [1,2,3] <*> [1]
21:38:33 <lambdabot> [1,2,3]
21:38:35 <kallisti> ah
21:39:12 <kallisti> @src (<*>)
21:39:12 <lambdabot> Source not found. Sorry.
21:39:32 <Deewiant> @src [] (<*>)
21:39:33 <lambdabot> (<*>) = ap
21:39:42 <kallisti> right right
21:39:52 <kallisti> :t ap
21:39:53 <lambdabot> forall (m :: * -> *) a b. (Monad m) => m (a -> b) -> m a -> m b
21:40:12 <kallisti> except...
21:40:13 <kallisti> oh
21:40:16 <kallisti> caleskell
21:40:30 <kallisti> > [1,2,3] >> []
21:40:30 <lambdabot> []
21:40:32 <kallisti> > [1,2,3] >> [1]
21:40:33 <lambdabot> [1,1,1]
21:40:42 <kallisti> hm no not quite
21:40:54 <kallisti> yes that's what I want actually.
21:42:45 <kallisti> > [1] >> [1,2,3]
21:42:45 <lambdabot> [1,2,3]
21:42:47 <kallisti> yes
21:48:09 <kallisti> >> is like product, `mplus` is like sum. :>
21:51:44 -!- Patashu has joined.
21:53:05 -!- Vorpal has quit (Ping timeout: 260 seconds).
21:57:02 <zzo38> kallisti: Yes it is the length of the list will be the product and sum!
21:58:48 <kallisti> zzo38: you can also use it to do and/or behavior
21:58:51 <kallisti> which is what I'm currently doing
21:59:08 <kallisti> though neither are commutative.
22:00:46 <zzo38> Astrology normally splits the ecliptic into twelve sections. For some purposes you might want an eight-section ecliptic instead. I think in some places they have some holidays on the 45 degrees and so on
22:05:40 <zzo38> How do you use it to do and/or behavior?
22:06:14 <kallisti> well list concatenation is essentially an or of two multi-valued logical assertions
22:07:37 <kallisti> and >>, though not really quite the same as and, will produce mzero when either of its terms does so.
22:09:59 <zzo38> Yes, it is the case for list monad. Not all monads follow the right zero law, however. But left zero law is implied by the type signatures and monad laws
22:10:01 -!- zzo38 has quit (Remote host closed the connection).
22:13:19 -!- oklopol has joined.
22:14:28 -!- Klisz has quit (Read error: Connection reset by peer).
22:14:56 -!- Klisz has joined.
22:18:47 <kallisti> hm
22:18:49 <kallisti> so
22:19:07 <kallisti> if I have a point+direction pair
22:19:45 <kallisti> what's the best way to compute a list of the chessboard squares that are a chebyshev distance of N away?
22:23:23 <kallisti> oh wait nevermind this should be pretty easy.
22:27:58 -!- Klisz has quit (Read error: Connection reset by peer).
22:28:26 -!- Klisz has joined.
22:30:13 -!- aloril has quit (Ping timeout: 255 seconds).
22:30:50 -!- aloril has joined.
22:32:15 <kallisti> :t Logic
22:32:15 <lambdabot> Not in scope: data constructor `Logic'
22:32:47 <kallisti> uh how do you mean Logics
22:32:50 <kallisti> *make
22:33:05 <kallisti> I guess with return.....
22:33:07 <kallisti> .
22:33:16 -!- augur has quit (Remote host closed the connection).
22:33:30 <kallisti> :t observeMany
22:33:30 <lambdabot> forall a. Int -> Logic a -> [a]
22:33:45 <kallisti> > observeMany $ msum . map return [1,2,3,4,5]
22:33:46 <lambdabot> Couldn't match expected type `GHC.Types.Int'
22:33:46 <lambdabot> against inferred type ...
22:33:53 <kallisti> > observeMany . msum . map return $ [1,2,3,4,5]
22:33:53 <lambdabot> Couldn't match expected type `GHC.Types.Int'
22:33:53 <lambdabot> against inferred type ...
22:33:57 <kallisti> > observeAll . msum . map return $ [1,2,3,4,5]
22:33:59 <lambdabot> [1,2,3,4,5]
22:34:36 <kallisti> I'm not entirely sure I understand the purpose of LogicT as it appears to just use lists...
22:34:57 -!- augur has joined.
22:35:09 <Sgeo> kallisti, multiple infinite lists don't play nicely
22:35:19 <kallisti> .. I'm aware
22:35:20 <kallisti> but
22:35:25 <kallisti> MonadLogic has a list instance.
22:35:26 <kallisti> so........
22:36:35 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (,) True
22:36:36 <lambdabot> Occurs check: cannot construct the infinite type: r = (a, r)
22:36:50 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> r) True
22:36:51 <lambdabot> True
22:36:54 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> r) False
22:36:55 <lambdabot> False
22:37:36 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> a == 0) False
22:37:38 <lambdabot> False
22:39:25 <kallisti> maybe it's more efficient.
22:43:52 <kallisti> or.... perhaps it's just an abstraction.
22:46:03 -!- Phantom_Hoover has quit (Quit: Leaving).
22:50:33 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> a) []
22:50:34 <lambdabot> No instance for (GHC.Num.Num [a])
22:50:34 <lambdabot> arising from a use of `e_112345' at <i...
22:50:39 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> a) 0
22:50:40 <lambdabot> 1
22:51:28 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> a:r) 0
22:51:29 <lambdabot> No instance for (GHC.Num.Num [a])
22:51:29 <lambdabot> arising from a use of `e_1123450' at <...
22:51:35 <kallisti> > runLogic (msum . map return $ [1,2,3,4,5]) (\a r -> a:r) []
22:51:36 <lambdabot> [1,2,3,4,5]
22:53:14 -!- DCliche has joined.
22:56:38 -!- Klisz has quit (Ping timeout: 245 seconds).
23:42:57 -!- Nisstyre has quit (Ping timeout: 240 seconds).
23:45:16 -!- Nisstyre has joined.
23:45:56 <kallisti> linearWalker :: (MonadState (S.Set Move) m, MonadPlus m) => WalkRule m
23:45:56 <kallisti> linearWalker = stopAtPiece `orRule` followPortal `andRule` unlessVisited
23:46:01 <kallisti> so good.
←2012-01-21 2012-01-22 2012-01-23→ ↑2012 ↑all