←2011-11-15 2011-11-16 2011-11-17→ ↑2011 ↑all
00:00:13 <elliott> oerjan: you mean, looking at the value at a cursor?
00:00:26 <elliott> that's not bad
00:00:47 <oerjan> well, finding the neighboring Seq's and stuff
00:01:01 <elliott> oh, OK
00:01:06 <elliott> so accessing the value at a cursor is still O(1)?
00:01:09 <oerjan> oh hm
00:01:17 <oerjan> well yeah that should be possible
00:01:29 <elliott> right
00:01:58 * elliott is probably more interested in the mutation performance :P
00:03:40 <oerjan> well to move a cursor along an edge, you would need to look up the neighboring Seq's and adjust them
00:04:29 <oerjan> oh in addition to neighboring Seq's there may also be neighboring collapsed trees with no other cursors adjacent
00:04:57 <elliott> i may not be following as closely as i thought >:)
00:05:04 <elliott> so do you have any idea what this would look like for an actual tree structure?
00:05:23 <oerjan> i think this may be a graph minor construction
00:05:51 <oerjan> erm
00:08:39 <CakeProphet> oerjan: so basically each Seq can have up to 2 cursors as parents?
00:08:43 -!- TeruFSX has quit (Read error: Connection reset by peer).
00:08:45 <oerjan> *-.-.-*-.-. *-*
00:08:45 <oerjan> | -> |
00:08:45 <oerjan> .-*-.-.-* *-+-*
00:08:49 <oerjan> CakeProphet: yes
00:09:12 <elliott> oerjan: that's pretty :')
00:09:23 <oerjan> the left part is the original tree with *'s as real cursors, the right is the collapsed tree, + is a virtual cursor
00:10:15 <elliott> ok
00:11:34 <CakeProphet> oerjan: what would be wrong with a BST of cursors that point to Seq leaves? (I don't think this terminology makes sense when dealing with graphs but whatever)
00:11:39 <oerjan> each of the right part - and | would be a Seq of the lines collapsed to it. oh hm i guess that doesn't show how there might be additional trees on those lines that are collapsed
00:11:47 <oerjan> what's a BST again
00:11:51 <CakeProphet> binary search tree.
00:12:15 <oerjan> well that's something like what i'm imagining
00:12:33 <CakeProphet> that is exactly what I'm imagining. :P
00:12:58 <CakeProphet> I guess you could use a 2-3 tree or some variation of a BST.
00:13:09 <oerjan> well it's just a dictionary?
00:13:20 <CakeProphet> ah, yes.
00:14:42 <CakeProphet> if by dictionary you mean a map implemented as a binary search tree. :)
00:14:59 <oerjan> that's afaik what haskell's Data.Map is.
00:15:05 <CakeProphet> yes.
00:15:29 <CakeProphet> wait so what about... Seq Cursors?
00:15:43 <oerjan> wat
00:15:46 <CakeProphet> no?
00:15:46 <CakeProphet> okay.
00:16:39 <CakeProphet> as in use a 2-3 finger tree to store a sequence of cursors, which point to two sub Seqs.
00:17:39 * oerjan head no wrap again
00:18:04 <elliott> oerjan: ignore that silly CakeProphet dude and tell me more :D
00:19:45 <oerjan> (*)(-.-.-)(*-.-.) *-*
00:19:45 <oerjan> (|) -> |
00:19:45 <oerjan> (.-*-)(.)(-.-)(*) *-+-*
00:19:58 <shachaf> \ o /
00:20:04 <shachaf> How does that bot work?
00:20:09 <oerjan> that shows precisely what part of the original is included in each char
00:20:14 <oerjan> on the right
00:20:16 <CakeProphet> ^celebrate
00:20:16 <fungot> \o| |o| |o/ \m/ \m/ |o/ \o/ \o| \m/ \m/ \o| |o| |o/
00:20:16 <myndzi> | | | `\o/´ | | | `\o/´ | | |
00:20:16 <myndzi> >\ |\ /< | /< /´\ >\ | >\ /< /|
00:20:16 <myndzi> (_|¯`\ /´\
00:20:16 <myndzi> |_) (_| |_)
00:20:20 <CakeProphet> shachaf: like that.
00:20:33 <CakeProphet> shachaf: also that's a human being not a bot. how rude!
00:20:42 <shachaf> \o/
00:20:42 <myndzi> |
00:20:43 <myndzi> /`\
00:20:46 <oerjan> oh oops
00:20:52 <oerjan> elliott: sorry, typo there
00:21:12 <oerjan> (*)(-.-.-)(*-.-.) *-*
00:21:12 <oerjan> (|) -> |
00:21:12 <oerjan> (.-*)(-)(.)(-.-)(*) *-+-*
00:21:21 <elliott> oerjan: ok
00:21:36 <elliott> oerjan: this is more efficient the closer each cursor is, right?
00:21:50 <oerjan> erm how so?
00:22:03 <elliott> oh, hmm, no
00:22:06 <elliott> i was misreading it :)
00:22:20 <CakeProphet> HASH TABLE OF CURSORS MUTABILITY YEAAAAH
00:22:23 <oerjan> the idea of the Seq's and collapsed subtrees is to make the parts between cursors O(1) to move in
00:22:45 <oerjan> well for a certain value of "1"
00:22:50 <elliott> oerjan: right
00:23:40 * CakeProphet writes a O(1) hash function that sleeps for 3 years before returning 1.
00:24:13 <CakeProphet> IT'S PRACTICALLY INSTANT.
00:24:54 <shachaf> O(noes)
00:25:03 <shachaf> ...As they say on the Internet.
00:25:24 <CakeProphet> I don't think you should ignore constant factors when your constant factor is 5 trillion.
00:25:27 <CakeProphet> silly Big O notation.
00:25:35 <elliott> `quote O\(slow\)
00:25:37 <HackEgo> 276) [on egojoust] <elliott> The fact is that EgoBot's % handling is O(slow) and O(big), and mine isn't.
00:25:53 -!- augur has quit (Remote host closed the connection).
00:25:57 <shachaf> `quote themselves
00:26:00 <HackEgo> No output.
00:26:05 <shachaf> `quote norway
00:26:07 <HackEgo> No output.
00:26:13 <shachaf> `quote lunch
00:26:15 <HackEgo> No output.
00:26:19 <shachaf> Useless bot.
00:26:26 <CakeProphet> `quote fuck
00:26:28 <HackEgo> 225) <ais523> I love the way zzo38's comment was cut off after the f of brainfuck <ais523> that's just the most hilarious place to cut it off in a discussion about censorshi \ 275) <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think <Gregor> oerjan: What - the - fuck \ 297) <oklopol> okay see in my head it went, you send from your other number smth like "i'd certainly
00:26:36 <elliott> `addquote <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:26:38 <HackEgo> 718) <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:26:43 <elliott> `quote themselves
00:26:44 <elliott> `quote norway
00:26:45 <HackEgo> 718) <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:26:46 <elliott> `quote lunch
00:26:47 <HackEgo> 718) <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:26:48 <HackEgo> 718) <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:26:58 <elliott> useful bot
00:27:01 <shachaf> `removequote <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:27:03 <HackEgo> ​/home/hackbot/hackbot.hg/multibot_cmds/lib/limits: line 5: exec: removequote: not found
00:27:10 <shachaf> `delquote <shachaf> `quote themselves <HackEgo> No output. <shachaf> `quote norway <HackEgo> No output. <shachaf> `quote lunch <HackEgo> No output. <shachaf> Useless bot.
00:27:11 <HackEgo> No output.
00:27:13 <shachaf> `ls bin
00:27:15 <HackEgo> ​? \ @ \ addquote \ allquotes \ calc \ define \ delquote \ etymology \ forget \ fortune \ frink \ google \ json \ k \ karma \ karma+ \ karma- \ learn \ log \ logurl \ macro \ marco \ paste \ pastekarma \ pastelog \ pastelogs \ pastenquotes \ pastequotes \ pastewisdom \ ping \ prefixes \ qc \ quote \ quotes \ roll \ runperl \ toutf8 \ translate \ translatefromto \ translateto \ units \ url \ wl \ word \ wtf
00:27:19 <CakeProphet> oerjan: please kick elliott for spam
00:27:23 <CakeProphet> also shachaf
00:27:28 <elliott> Also CakeProphet.
00:27:29 <CakeProphet> :< <-- grumpy old man
00:27:30 <shachaf> `quote CakeProphet
00:27:32 <HackEgo> 141) <CakeProphet> how does a "DNA computer" work. <CakeProphet> von neumann machines? <Phantom_Hoover> CakeProphet, that's boring in the context of DNA. <Phantom_Hoover> It's just stealing the universe's work and passing it off as our own. \ 142) <fungot> CakeProphet: reading herbert might be enlightening in one hand he held a long worm can be greased. twice i got it nearly there, and the protector of cattle. mars is
00:27:51 <elliott> oerjan: the idea is basically to turn a tree with a bunch of cursors into a tree of /just/ the cursors, retaining their sort of "relative positions", right?
00:28:03 <elliott> and those cursors contain the bits of the tree they're focusing on, sort of
00:28:31 <oerjan> yeah
00:28:41 <oerjan> (*)(-.-)(*)(-.-.-.) *-*
00:28:42 <oerjan> (|) -> |
00:28:42 <oerjan> (.-*)(-)(.)(-.-)(*) *-+-*
00:29:05 <shachaf> let |x| = abs x; o = -5 in |o|
00:29:05 <myndzi> |
00:29:05 <myndzi> /<
00:29:07 <elliott> oerjan: this is a Seq zipper, right?
00:29:12 <oerjan> that's what the previous should become if we move the upper right * cursor one step left
00:29:51 <CakeProphet> shachaf: one day Haskell will DWIM.
00:29:52 <oerjan> now the middle | Seq line contains -.-.-.
00:29:54 <elliott> oerjan: (i forgot which structure you were zippering :P)
00:30:16 <oerjan> |
00:30:22 <oerjan> dammit
00:30:38 <oerjan> * |
00:30:45 <shachaf> CakeProphet: One day it will DWIM; I dearly hope that the day will never come when it DWYM, though.
00:30:52 <CakeProphet> zippered finger trees.
00:30:56 <elliott> oerjan: kick shachaf for interrupting your diagram
00:31:07 <elliott> CakeProphet: Seq /is/ a finger tree
00:31:09 <oerjan> so there's an actual tree in one of the Seq elements on the way
00:31:14 <CakeProphet> elliott: /really/?
00:31:16 * CakeProphet gasps.
00:32:34 <CakeProphet> therefore, hash tables are arrays.
00:33:03 <shachaf> Table#
00:33:15 <oerjan> elliott: i'm zippering a plain unrooted tree, essentially
00:33:22 <elliott> oerjan: ok
00:33:41 <oerjan> adding labels and typesafeness left as an exercise for the reader >:P
00:33:51 <elliott> oerjan: when do you get to defining adts >:)
00:34:11 <oerjan> LEFT AS AN EXERCISE FOR THE READER, I SAID
00:34:35 <elliott> oerjan: :'(
00:34:41 <shachaf> oerjan: Why aren't you in #haskell these days?
00:34:58 <elliott> dammit, oerjan has roped me into listening to one of his long monologues and getting /nothing/ useful out of it :P
00:34:59 * shachaf checks #haskell. <stribor> you mean line this....once oi am on unix command line to do this .....ghci -package gtk ?
00:35:02 <shachaf> Hmm.
00:35:07 <oerjan> *MWAHAHAHA*
00:35:36 <elliott> oerjan: im going to cry at you now instead of replying to anything you say.
00:35:37 <elliott> oerjan: cry
00:36:03 <shachaf> Sounds to me, oerjan, like elliott mad
00:36:19 <shachaf> Sounds to me, elliott, like u mad
00:36:26 <oerjan> well there's a sort of dynamicity at the point of mapping back from the collapsed tree to the original which i'm not quite sure how to handle
00:36:53 <monqy> CakeProphet: ><{{{}::LLKLMH@A;'`hi`1 s
00:37:06 <oerjan> like, to get full typesafeness we'd need some kind of parametric Seq
00:37:39 <oerjan> and with things in a map it might involve actual Dynamic
00:38:14 <shachaf> unsafeCoerce
00:38:23 <elliott> oerjan: hm do you need an indexed map
00:38:53 <oerjan> oh and it might be necessary to invent id's for the cursors
00:38:54 <elliott> oerjan: i.e. lookup :: k a -> Map k a -> Maybe a
00:38:57 <shachaf> elliott: Did you see ddarius's puzzle about IORef in #haskell recently?
00:38:58 <elliott> or similar
00:39:01 <elliott> shachaf: No.
00:40:01 <shachaf> do { r <- newIORef (return ()); writeIORef r (join (putChar '*' >> readIORef r)); join (readIORef r) }
00:40:20 <shachaf> The puzzle went "where does the recursion come from?".
00:40:27 <shachaf> Or something along those lines.
00:41:39 <elliott> shachaf: I...
00:41:59 <elliott> shachaf: It comes from executing the result of reading r depending on the value inside r.
00:42:04 <elliott> Which it executes.
00:42:08 <elliott> And so on.
00:42:13 <shachaf> Right, but there's no recursive definition there.
00:42:25 <shachaf> And yet it's non-terminating.
00:42:28 <shachaf> How does that happen?
00:42:31 <elliott> shachaf: There sort of is; it's using the IORef as a definition.
00:42:32 <oerjan> there's a cyclic structure created by mutation
00:42:40 <elliott> Yeah.
00:42:53 <shachaf> OK, but why are you allowed to create a cyclic structure?
00:43:09 <CakeProphet> because IO etc
00:43:17 <shachaf> Well, it works with ST too.
00:43:18 <elliott> shachaf: As opposed to...?
00:43:22 <shachaf> Can you model this with State, for instance?
00:43:24 <oerjan> because that's easy with IORef?
00:43:42 <elliott> You can do a mono-typed STRef with State, so yes.
00:43:43 <oerjan> heh
00:43:50 <elliott> Since only one relevant reference type is used here.
00:44:00 <CakeProphet> *x = &x //weeeeeeeee
00:44:04 <shachaf> elliott: OK, can you do it with State, then, without using any recursion?
00:44:53 <elliott> shachaf: main = runStateT (do { put $ join (liftIO (putChar '*') >> get); join get) (return ())
00:44:54 <elliott> ?
00:45:06 <elliott> shachaf: main = runStateT (do { put $ join (liftIO (putChar '*') >> get); join get }) (return ())
00:45:22 <elliott> Occurs check: cannot construct the infinite type:
00:45:22 <elliott> m1 = StateT (m1 ()) m0
00:45:22 <elliott> :-(
00:45:49 <elliott> Oh.
00:45:53 <elliott> shachaf: You just need a newtype wrapper.
00:46:01 <elliott> newtype Foo = Foo (StateT Foo IO)
00:46:03 <oerjan> > runRWS (do put (join (tell "*" >> get)); join get) undefined undefined
00:46:04 <lambdabot> Occurs check: cannot construct the infinite type:
00:46:05 <lambdabot> m
00:46:05 <lambdabot> =
00:46:05 <lambdabot> Control.Mona...
00:46:13 <shachaf> elliott: Can you get the IO out of this, please?
00:46:15 <oerjan> :t runRWS
00:46:16 <lambdabot> forall r w s a. RWS r w s a -> r -> s -> (a, s, w)
00:46:19 * shachaf should never have brought up IO.
00:46:27 <elliott> shachaf: What kind of effect do you want, then? Just plain _|_?
00:46:31 <shachaf> Sure.
00:46:43 <shachaf> _|_ without recursion is accomplishment enough. :-)
00:46:56 <CakeProphet> > undefined
00:46:57 <lambdabot> *Exception: Prelude.undefined
00:47:02 * CakeProphet feels accomplished
00:47:06 <shachaf> @slap CakeProphet
00:47:06 * lambdabot karate-chops CakeProphet into two equally sized halves
00:47:12 <elliott> shachaf: Lesse...
00:47:40 <elliott> s/sse/ssee/
00:47:47 <shachaf> Anyway, yes, that was recursive. :-)
00:47:59 -!- hagb4rd has quit (Ping timeout: 240 seconds).
00:48:02 <oerjan> shachaf: i think the only reason my RWS version doesn't work is that the state is contained in the monad type, unlike for IO, so it needs a newtype wrapper
00:48:30 <oerjan> otherwise i think it is in spirit the same as the IO one
00:48:46 <elliott> shachaf: Done.
00:48:52 <elliott> ewtype Foo a = Foo { unFoo :: State (Foo ()) a }
00:48:52 <elliott> test = Foo $ do
00:48:52 <elliott> put $ Foo (get >>= unFoo)
00:48:52 <elliott> get >>= unFoo
00:48:55 <elliott> *Main> evalState (unFoo test) undefined
00:48:55 <elliott> Loading package transformers-0.2.2.0 ... linking ... done.
00:48:58 <elliott> s/ewtype/newtype/
00:49:05 <shachaf> Well, you're using a recursive newtype.
00:49:21 <elliott> shachaf: So is IO.
00:49:26 <elliott> IORefs are just magical.
00:49:49 * elliott isn't sure exactly what you're getting at here.
00:50:22 <shachaf> What's recursive about STRef?
00:50:42 <elliott> shachaf: ST has a store of STRefs which you instantiate polymorphically to make them include an ST.
00:50:58 <oerjan> shachaf: the problem is that only IO and ST allows you to make state that doesn't show up in the type of the monad
00:50:58 <elliott> But fine, I'll whip up a version without that.
00:51:21 <oerjan> that is why they don't need a newtype
00:51:27 <shachaf> oerjan: Right.
00:51:37 <elliott> Actually I can't, I'd need unsafeCoerce I think.
00:51:44 <elliott> Unless, hmm...
00:51:50 <elliott> shachaf: But yeah, what is the point actually meant to be?
00:52:27 <oerjan> elliott: maybe Dynamic is sufficient?
00:52:48 <elliott> oerjan: Hmm, right
00:52:51 * elliott tests
00:54:13 <elliott> No instance for (Typeable1
00:54:13 <elliott> (StateT Dynamic Data.Functor.Identity.Identity))
00:54:14 <elliott> Hmph.
00:54:17 * elliott newtype
00:55:39 <elliott> Can't make a derived instance of `Typeable1 (StateT a m)':
00:55:39 <elliott> `StateT' has arguments of kind other than `*'
00:55:39 <elliott> In the stand-alone deriving instance for `Typeable1 (StateT a m)'
00:56:03 * elliott makes own monad
00:59:13 <elliott> shachaf: Done.
00:59:59 <elliott> shachaf: http://hpaste.org/54087
01:01:44 <elliott> shachaf: HAPPY NOW?
01:02:07 <elliott> shachaf: (I note that you can implement Y without explicit value or type recursion using Dynamic too.)
01:02:57 <elliott> oerjan: SO N-CURSOR ZIPPERS
01:04:10 <CakeProphet> elliott: I will substitute for oerjan
01:04:13 <elliott> shachaf: Also, I believe this means you can do recursion with "just" the FFI, and with "just" Chans and forkIO.
01:04:14 <CakeProphet> so basically like
01:04:17 <CakeProphet> n-cursor zippers
01:04:19 <CakeProphet> are like zippers
01:04:22 <CakeProphet> but with n cursors.
01:05:11 <oerjan> you can even do recursion with "just" recursion.
01:05:26 <elliott> indeed!
01:05:30 <elliott> so oerjan, n-cursor zippers
01:05:54 <oerjan> i sense some recursoring
01:07:03 <elliott> very funny. HELP ME OUT, I AM AT WAR WITH FINNS.
01:07:57 <oerjan> maybe we could do a zipper of the collapsed tree to easily move to the cursor we want to concentrate on >:)
01:08:33 <elliott> oerjan: :D
01:09:06 -!- tiffany has quit (Quit: nyu~).
01:10:21 <oerjan> then we wouldn't need a dictionary to get back to the original tree. although we still need some map to tell the path to each cursor. ouch.
01:11:17 <oerjan> and that map would change as cursors move
01:11:59 <oerjan> especially since the shape of the collapsed tree also can change
01:12:02 <elliott> oerjan: what, exactly, kind of dictionary do you need?
01:14:17 <oerjan> oh hm. maybe we could put signposts in the virtual cursor data to tell how to move to another cursor - only the next step, so changes are still local
01:14:37 <oerjan> a zipper of the zipper starts looking sane...
01:15:06 <elliott> coooool
01:16:31 <CakeProphet> elliott: http://dl.dropbox.com/u/16495819/lolncursor.png
01:16:32 <oerjan> oh, this would get O(n) in the number of cursors if they're laid out on a line
01:16:35 <CakeProphet> Nobel Prize plz
01:16:46 <elliott> oerjan: O(n) to do /what/?
01:17:00 <elliott> CakeProphet: now tell me how to reposition cursor 3 before cursor 2
01:17:23 <CakeProphet> do lots of swappy things.
01:17:52 <oerjan> CakeProphet: the cursors are not necessarily ordered in that way.
01:18:06 <oerjan> that's the whole point of this collapsed tree thing
01:18:19 -!- derdon has quit (Remote host closed the connection).
01:18:23 <CakeProphet> hmmmmmmmm
01:18:26 <CakeProphet> okay
01:18:59 <oerjan> elliott: to move from one cursor to another if you have to pass all the others, if they're extremes on a line
01:19:16 <oerjan> with the zipper of zipper idea
01:19:35 <CakeProphet> how do you intend to access the cursors?
01:19:37 <elliott> oerjan: ah. that's probably not hugely problematic, i think the most number of IPs any funge program has is like 60,000, and that's pathological
01:19:42 <CakeProphet> random access, sequentially, ????
01:19:47 <elliott> a few hundred at most is all i care to optimise for
01:19:58 <CakeProphet> by an identifier, by an index?
01:21:01 <elliott> CakeProphet: round-robin, for my usecase
01:21:06 <CakeProphet> ah
01:21:28 <CakeProphet> well you could just decouple the subsequences...
01:21:32 <CakeProphet> basically a Seq of zippers.
01:21:37 <CakeProphet> on the same list.
01:21:51 <elliott> i'll let oerjan respond to you >:)
01:21:57 <elliott> oerjan: but anyway, what kind of dictionary /did/ you need?
01:22:37 <oerjan> elliott: at this point, i think you only need dictionaries or something for the signposts
01:22:51 <elliott> oerjan: I meant to avoid the zipper-zipper inefficiency, but ok
01:22:58 <oerjan> a signpost would tell for each real cursor what direction to go in
01:22:59 <oerjan> oh.
01:23:07 <CakeProphet> psh Seq of zippers is mad efficient.
01:24:52 <oerjan> so, a virtual cursor node would need to contain some data: a list of adjoining trees without cursors in them, a list of adjoining Seq's to other cursors, and some tag to tell which nearest neighbors are in which relation to each other in the original QuadTree. and possibly the signpost map.
01:25:36 <oerjan> oh and the adjoining Seq's would of course "end" in cursor-cursors with the zipper zipper idea
01:25:40 -!- augur has joined.
01:25:51 <elliott> oerjan: ok
01:26:17 <CakeProphet> also a ref to the mutable 2D array that it can use to mutate the fungespace and move IPs in constant time.
01:26:47 <CakeProphet> >:>
01:26:48 <oerjan> if you don't do the zipper of zipper idea, you need to handle the collapsed tree in some other way, perhaps using some graph library.
01:27:10 <elliott> oerjan: ok, stick with zipper of zipper i guess :P
01:27:14 <elliott> it sounds easier
01:27:19 <CakeProphet> s/zipper/Seq/
01:27:32 * oerjan swats CakeProphet -----###
01:28:42 <Gregor> WLIIA REPORT AS OF 1x15: Absolute winner is still Wayne Brady with an incredible 3,003,530.5 points. Absolute average episode winner is also Wayne with 250,294.2 points. Logarithmic winner is Ryan Stiles in a come-from behind victory with 82, barely beating out Colin's 80.6. Logarithmic average episode winner for performers appearing in >1 episode is Wayne with 6 log-points per episode.
01:29:05 <CakeProphet> ?
01:29:16 <Gregor> CakeProphet: I'm watching all of Whose Line is it Anyway and tallying the points.
01:29:28 <CakeProphet> elliott: clearly Wayne Brady is the best choice for implementation of n-cursor zippers.
01:29:35 <CakeProphet> Gregor: white people love Wayne Brady.
01:29:49 * shachaf return
01:30:23 * CakeProphet CakeProphet >>= eat soup
01:30:26 <CakeProphet> erm
01:30:30 * CakeProphet >>= eat soup
01:31:14 * shachaf shachaf shachaf *
01:31:22 <pikhq_> Gregor: First, why the heck are you doing that?
01:31:46 <pikhq_> Second, :)
01:32:59 <Gregor> pikhq_: As an excuse to watch WLIIA :P
01:33:08 <pikhq_> Good reason.
01:34:17 <elliott> oerjan: go on :
01:34:17 <elliott> :P
01:34:51 <CakeProphet> Gregor: the handsome black man is the best to watch.
01:35:00 <CakeProphet> also Drew Carrey may have a mancrush on him
01:37:03 <elliott> y :: (Typeable c, Typeable b) => (b -> c) -> c
01:37:07 <elliott> shachaf: My fixed-point combinator is swell.
01:37:51 <monqy> swellest
01:38:01 <oerjan> the basic NW, NE, SW, SE, FromNW, FromNE, FromSW, FromSE directions from QuadTrees still apply to all of this, i think.
01:38:12 * CakeProphet >>= eat soup >>= feelMMM
01:38:15 <CakeProphet> mmm
01:38:18 <monqy> mmm
01:38:20 <elliott> oerjan: ok
01:39:25 <oerjan> a cursor cursor would go in one of those. if one of the four first, it would be sort of like a QuadTree, if one of the four latter, like a Cursor in our previous discussions
01:39:50 -!- augur has quit (Remote host closed the connection).
01:41:19 <oerjan> there would be two types of such, those with a (virtual) cursor at the other end, and those without. the latter would actually _be_ QuadTrees and Cursors of our previous talks.
01:41:26 <CakeProphet> oerjan: I think you guys are overcomplicated this..
01:41:50 <elliott> CakeProphet: present your solution or shut up and stop butting in :P
01:41:55 <oerjan> the former would contain a Seq, a new direction, and a virtual cursor node.
01:42:16 <Gregor> OMG, owcc is SO FRIGGIN' SLOW
01:42:32 <oerjan> the terminology of this is definitely going to hell.
01:42:35 <Gregor> elliott: Lest you're not up to date: x86[_64], SPARC, MIPS[el]
01:42:42 <Gregor> Not as big a list as I'd like :(
01:42:55 <elliott> Gregor: I was up to date. Make it work on ARM and PPC. :p
01:42:55 <Gregor> Also, tcc seems to exclusively generate retarded function prologues.
01:42:57 <elliott> oerjan: yes, quite
01:43:04 <elliott> oerjan: maybe some ADT definitions would help >:)
01:43:13 <oerjan> also, in principle we would want type parametrized Seq's so we could actually keep things typesafe
01:43:35 <Gregor> elliott: With -O2: 7b: 81 ec 00 00 00 00 sub $0x0,%esp
01:44:02 <CakeProphet> elliott: what I had in my diagram. just do swappy stuff when you need to rearrange cursors.
01:44:11 <elliott> CakeProphet: What the fuck is "swappy stuff"?
01:44:33 <CakeProphet> if that's too inefficient, just do a Seq/container-of-preference of zippers because.
01:44:41 <oerjan> some kind of PSeq f a b which is a chain of f a c1, f c1 c2, ..., f cn b
01:44:55 <shachaf> elliott: Swell as in unsafeCoerce?
01:45:04 <elliott> shachaf: Nah, the next best thing.
01:45:05 <oerjan> f would be a gadt, i think
01:46:07 <shachaf> elliott: Dynamic = unsafeCoerce.
01:46:37 * oerjan is worried that part needs ContextKinds
01:46:44 <oerjan> er
01:46:50 <oerjan> *ConstraintKinds
01:47:27 <CakeProphet> elliott: rearrange the cursors so they're in order, concat and move stuff around. profit.
01:48:08 <CakeProphet> if what's between two cursors isn't relevant, just do the Seq of zippers. that's more efficient.
01:49:16 <elliott> y :: forall a. (Typeable a) => (a -> a) -> a
01:49:16 <elliott> y f = fromDyn' (magic (toDyn magic))
01:49:16 <elliott> where magic :: Dynamic -> Dynamic
01:49:16 <elliott> magic x = toDyn (f (fromDyn' (dynApp x (toDyn x))))
01:49:19 <elliott> shachaf: It doesn't work :-(
01:49:44 <elliott> CakeProphet: A Seq of zippers doesn't let you mutate, which is the whole bloody point.
01:49:58 <shachaf> elliott: Why are you using Dyn instead of just recursive types?
01:50:01 <CakeProphet> elliott: but assuming the cursors are IPs then I'm guessing they only move around in increments of 1?
01:50:13 <elliott> shachaf: To prove you can do fix without type or value-level recursion.
01:50:21 <elliott> CakeProphet: I really can't be bothered explaining this to you?
01:50:21 <shachaf> By using unsafeCoerce.
01:50:31 <elliott> shachaf: Yes, except it's safeCoerce.
01:51:14 <shachaf> @let safeCoerce :: a -> a; safeCoerce x = unsafeCoerce x
01:51:16 <lambdabot> Defined.
01:51:48 <monqy> > safeCoerce 5
01:51:54 <lambdabot> mueval: ExitFailure 1
01:51:54 <lambdabot> mueval-core: Time limit exceeded
01:51:56 <monqy> lambdabot.....
01:52:15 <shachaf> > safeCoerce 5
01:52:15 <CakeProphet> :t safeCoerce
01:52:17 <lambdabot> forall a. a -> a
01:52:17 <lambdabot> 5
01:52:25 <CakeProphet> @src safeCoerce
01:52:28 <lambdabot> Source not found. Are you on drugs?
01:52:35 * oerjan facepalm
01:52:40 <monqy> cake "whats paying attention" prophet
01:53:04 <CakeProphet> whats paying attention?
01:53:16 <monqy> oh no......
01:54:00 <CakeProphet> I often make fools of yourself.
01:54:14 <monqy> yes
01:54:48 <CakeProphet> monqy avoids making fools of yourself by only talking when he is not a fool.
01:54:53 <CakeProphet> good strategy.
01:55:57 <elliott> monqy is never fool
01:59:09 <CakeProphet> therefore monqy only talks.
02:01:38 <CakeProphet> Gregor "unrelated" Richards
02:03:53 <Gregor> HEYO
02:04:05 <CakeProphet> O YEH
02:04:10 <Gregor> The very first instance of Scenes from a Hat (in spite of it being a staple of the show) is in the 16th episode.
02:05:18 -!- CakeProphet has changed nick to RogerG\unhere.
02:05:39 <monqy> bye roger g
02:06:32 <Gregor> Argh, how do I stop making owcc do semi-clever inter-procedural optimization >_>
02:07:34 <monqy> does owcc have -O0
02:07:44 <RogerG\unhere> Gregor: write inefficient code.
02:07:50 <RogerG\unhere> and it will negate the effect.
02:08:02 <monqy> don't have procedures
02:08:29 <pikhq_> Have enough procedures that owcc overflows something.
02:09:01 -!- Slereah_ has joined.
02:10:40 -!- Slereah has quit (Ping timeout: 255 seconds).
02:10:51 <Gregor> monqy: Doesn't work with -O0 because it generates subl $0, %esp
02:11:35 <pikhq_> Gregor: ...
02:11:46 <Gregor> pikhq_: Yup.
02:12:04 <monqy> owcc...
02:12:24 -!- RogerG\unhere has quit (Ping timeout: 252 seconds).
02:12:36 <monqy> bye roger g
02:13:17 <Gregor> monqy: OpenWatcom.
02:13:42 <monqy> Oklahoma Workers' Comensation Court
02:14:04 <monqy> Old Whitgiftians Cricket Club good
02:15:08 <monqy> The code it produces for MS-DOS executes very fast[citation needed]. It was one of the first compilers to support the Intel 80386 "protected mode"[citation needed].
02:15:11 <monqy> thanks wikipedia
02:15:59 <pikhq_> It's ye old Watcom compiler, GPL'd.
02:21:37 <Gregor> OK, so far nothing but gcc can make my JIT work X-P
02:21:41 <Gregor> Everything else is SO CLOSE and yet so far.
02:21:47 <Gregor> Compiler suggestions?
02:22:19 <pikhq_> tcc?
02:22:32 <pikhq_> If you can compile it with otcc even better.
02:22:49 <Gregor> tcc always generates subl $0, %esp
02:22:57 <pikhq_> otcc likewise? :(
02:23:03 <Gregor> Haven't tried it.
02:23:12 <pikhq_> It probably does.
02:23:21 <pikhq_> Seeing as it's what tcc came from.
02:23:42 <pikhq_> Still, it'd be pretty spiffy to compile with a previous entry to IOCCC.
02:24:59 <Gregor> True ...
02:25:17 <Gregor> I wonder if with sufficient cleverness I could do epilogue detection only and leave in the prologues and partial epilogues for everything ...
02:25:53 <Gregor> OR I could be REALLY stupid and just assume that your epilogue is either one or four bytes and no other size :P
02:28:20 <Gregor> Nope, wouldn't work on SPARC :P
02:29:32 <Gregor> (Or anything else with delay branches ... )
02:33:24 <Gregor> BUT, if I assume that on all CISC platforms (all one of them), I may be in luck.
02:41:19 <Gregor> HEYOOOOO
02:43:14 <Gregor> OpenWatcom :)
02:43:29 <Gregor> And probably TCC
02:47:09 <elliott> Gregor: By doing what
02:52:28 <Gregor> Yup, works on TCC too :)
02:52:33 <Gregor> elliott: Making my heuristics much more stupid.
02:52:40 <elliott> lol
02:52:50 <Gregor> elliott: On platforms I determine to be CISC, I blindly assume the epilogue is always one byte and the prologue is zero.
02:55:16 -!- MDude has changed nick to MSleep.
02:57:07 -!- calamari has joined.
02:57:23 <elliott> Gregor: How do you determine ciscness?
02:57:34 <Gregor> elliott: Odd-sized functions.
02:57:45 <elliott> That's it?
02:57:46 <Gregor> Yup
02:58:12 <Gregor> I'm not exactly aiming for coding perfection here :P
02:58:13 <oerjan> an odd heuristic
02:58:26 <Gregor> oerjan: AND YET: It works :)
02:59:21 <elliott> oerjan: ADTS PLZ
02:59:37 <oerjan> i knew i'd regret that pun
03:02:50 <Gregor> And now to lament the lack of -mbuild-constants for ARM :(
03:14:33 <elliott> oerjan: :|
03:14:42 <oerjan> it's tricky
03:14:53 <elliott> pah :P
03:15:29 <elliott> oerjan: btw the space is actually finite
03:15:39 <elliott> (Int32,Int32)-indexed
03:16:03 -!- pikhq has joined.
03:16:09 <oerjan> ic, well that's just having some top node
03:16:12 -!- pikhq_ has quit (Ping timeout: 260 seconds).
03:17:06 <elliott> yeah
03:17:20 <elliott> not like you can allocate that much anyway
03:17:33 <elliott> so might as well just leave it out
03:18:30 <oerjan> data MetaCursor srcdir = MCPlain (PlainCursor srcdir) | forall dest. MCPath (MetaPath src dest) MetaNode dest
03:18:48 <elliott> ooh, that looks cool
03:19:53 <elliott> oerjan: s/srcdir/src/g right?
03:20:00 <oerjan> oh hm
03:20:11 <oerjan> or the reversze
03:20:14 <oerjan> *-z
03:20:29 <elliott> then you vneed to rename dest >:)
03:20:33 <oerjan> gah
03:20:34 <elliott> src is nicer anyway
03:21:34 <oerjan> data FromNW; data FromNE; data FromSW; data FromSE; data NW; data NE; data SW; data SE -- src and dest should be one of these
03:22:08 <elliott> ok
03:25:35 <oerjan> PlainCursor From{NW,NE,SW,SE} is basically our old Cursor and PlainCursor {NW,NE,SW,SE} is a QuadTree, i think
03:25:57 <elliott> gadts then :P
03:26:00 <oerjan> yeah
03:26:16 <elliott> i forget our old cursor but i'll look it up when i need it
03:26:32 <oerjan> *(MetaNode dest) -- forgot parens above
03:26:37 <pikhq> Aaah, earl grey.
03:27:56 <elliott> oerjan: btw just out of curiosity, does it help optimise the metazipper thing if you know i always access cursors in round-robin
03:28:17 <elliott> not round-robin in order of space; in order of creation
03:28:24 <oerjan> ic
03:28:47 <Gregor> OK, I may have this working on ARM, and only 85% incurably stupid.
03:29:15 <elliott> oerjan: i'll shut up :)
03:29:56 <oerjan> that means you basically wants CakeProphet's Seq of zippers in ther somehow ;P
03:30:05 <oerjan> *+e
03:31:27 <elliott> might as well just continue as-is :P
03:32:11 <oerjan> MetaNode dest represents a node containing a virtual cursor, with incoming edge as dest
03:32:20 <Gregor> Damn it, now how did this break on MIPS >_>
03:33:24 <elliott> oerjan: ok
03:34:18 <oerjan> oh hm
03:34:21 -!- augur has joined.
03:35:11 <oerjan> MNFromNW :: { neNeighbor :: MetaCursor NE, ... but what should be the _up_ cursor...
03:35:53 <oerjan> i think it needs to be split. ah!
03:36:12 <oerjan> data From; data To; data NW; ...
03:36:34 <elliott> :D
03:36:48 <elliott> oerjan: From dir
03:36:53 <elliott> and To dir
03:36:56 <elliott> no
03:37:00 <elliott> ?
03:37:07 <oerjan> oh well maybe
03:37:17 -!- augur has quit (Remote host closed the connection).
03:37:33 <oerjan> i was thinking of them as separate arguments, but i guess that works too
03:38:09 <elliott> ah
03:39:33 <oerjan> MNFromNW :: { neNeighbor :: MetaCursor (To NE), swNeighbor :: MetaCursor (To SW), seNeighbor :: MetaCursor (To SE), up :: MetaCursor (From dir), signPost :: SignPost } -> MetaNode (From NW)
03:39:57 <oerjan> not sure that's the right syntax
03:40:19 <elliott> i think its {a::b} -> {c::d} -> ...
03:40:25 <elliott> but i prefer yours :)
03:40:28 <oerjan> oh
03:42:50 <oerjan> MNToNW :: { ... like above but with all five neighbors and no up }
03:42:57 <oerjan> oh hm
03:43:02 <oerjan> obviously then
03:43:20 <elliott> what is dir in MNFromNW
03:43:21 <oerjan> MNTo :: { ... } -> MetaNode (To dir)
03:43:28 <elliott> ah
03:43:50 <elliott> NW then
03:43:56 <oerjan> it doesn't need a different constructor for different ones on the To
03:44:03 <oerjan> *MNTo
03:45:11 <oerjan> the dir in the up field of MNFromNW is arbitrary, since we don't know which direction this node is from the up node
03:45:22 <elliott> oerjan: you mean all 4 neighbours right?
03:45:25 <elliott> and ah
03:45:28 <oerjan> oops :P
03:47:47 <Gregor> elliott: So yeah, +ARM anyway :P
03:48:10 <elliott> Gregor: +ARM-MIPS
03:48:23 <Gregor> elliott: I'm fixin' MIPS :P
03:49:18 <oerjan> MetaPath src dir is tricky. it should be a chain of, hm, PathNode s d, using some kind of Seq which _ideally_ would be parametrized such that only consecutive PathNodes need to match in types
03:50:43 <elliott> does that really matter for internals? :
03:50:45 <elliott> :P
03:50:46 <oerjan> oh and it should probably have a tag so you could consider one as "reversed", for when you "metazip" around it
03:51:04 -!- augur has joined.
03:51:42 <oerjan> without needed to _actually_ traverse and reverse the pathnodes
03:51:45 <oerjan> *needing
03:51:50 <elliott> right
03:52:24 <oerjan> well if you don't do that then of course the typesafe directions break down inside these paths.
03:52:33 <elliott> hm right
03:52:39 <elliott> go ahead, then :P
03:52:55 <oerjan> (i am simply assuming the existence of such a Seq)
03:53:20 <oerjan> which i think i called PSeq above
03:54:26 <oerjan> data MetaPath src dir = MP (PSeq PathNode src dir) | MPReversed (PSeq PathNode dir seq)
03:54:35 <elliott> ok
03:55:08 <elliott> the reversing thing might be better to put into pseq itself but never mind that for now...
03:55:58 <oerjan> well i was just assuming a PSeq which did the minimal change to Seq to make it parametric
03:56:15 <elliott> right
03:56:30 <oerjan> hm...
03:56:46 <elliott> s/seq/src/ :p
03:57:06 <oerjan> oops
03:59:02 <oerjan> PN_ToNW_ToNW :: { neNeighbor :: PlainCursor (To NE) } -> { swNeighbor :: ... } -> { seNeighbor :: ... } -> PlainNode (To NW) (To NW)
03:59:44 <oerjan> similarly for PN_To**_To**
03:59:55 <elliott> ok. (i preferred the previous syntax :P)
04:00:31 <oerjan> PN_To**_From** is illegal
04:01:02 <Gregor> elliott: I officially have no clue why MIPS is broken :P
04:01:39 <oerjan> PN_FromNW_FromNW :: { neNeighbor :: ..., swNeighbor :: ..., seNeighbor :: ... } -> PlainNode (From NW) (From NW)
04:02:01 <oerjan> same arguments, actually, it's conceptually the reversed version of the first one
04:02:30 <oerjan> and so PN_From**_From** in general
04:03:39 -!- madbr has joined.
04:03:47 <oerjan> PN_FromNW_ToNE :: { swNeighbor :: PlainCursor (To SW), seNeighbor :: PlainCursor (To SE), up :: PlainCursor (From dir) } -> PlainNode (From NW) (To NE)
04:04:07 <oerjan> and PN_From**_To** in general, except not with the two directions equal
04:04:22 <oerjan> i think that's all for PlainNode
04:06:30 <elliott> back, sorry
04:06:42 <oerjan> SignPost would be a map whose keys are real cursors and whose values are Maybe Direction
04:06:56 <elliott> oerjan: re: to/from, couldn't you have ... -> PlainNode (tofrom NW) (tofrom NW) >:)
04:07:01 <elliott> just kidding >_>
04:07:18 <oerjan> AAAAAAAAAAAAAAAAAAAAAA
04:07:37 <oerjan> Direction would be a value form of the To dir, From dir things.
04:07:44 <elliott> right
04:08:05 <elliott> oerjan: (more seriously, it seems to me like a type AllDirectionsBut wrapper dir would cut down on lots of duplication)
04:08:32 <oerjan> maybe. note that the PN_From**_To** miss _two_ directions.
04:08:37 <elliott> ah
04:08:45 <elliott> what's a real cursor? the previous Cursor? PlainCursor?
04:09:32 <oerjan> your ip id, i think
04:09:43 <elliott> oerjan: oh, so just an identifier? ok
04:10:01 <oerjan> and a value of Nothing indicates that it's at _this_ node
04:10:14 <elliott> oerjan: (i am half-considering putting the rest of the IP data into this structure, since it's basically tracking my IPs anyway...)
04:10:16 <oerjan> while Just dir indicates where to start going to find it
04:10:51 <oerjan> ah in that case you could use Either IpData Direction for the values, i guess
04:10:57 <elliott> right
04:11:11 <elliott> i am shocked to find myself actually understanding all this.
04:11:21 <oerjan> yay
04:11:48 <Gregor> elliott: It's some weird interaction between unconditional jumps and conditional jumps >_O
04:13:17 <elliott> oerjan: i thought i had lost all hope of understanding after last time's 15 constructors :D
04:13:26 <oerjan> :P
04:14:24 <Gregor> elliott: AHAAAAAAAAAAAAA scratch registers boo.
04:14:35 <oerjan> oops, s/PlainNode/PathNode/g in some of the above
04:14:46 <elliott> oerjan: oh. now it makes even more sense!
04:15:15 <oerjan> yay
04:15:26 <elliott> oerjan: er, that's not it, right?
04:16:04 <oerjan> i think PathNode has 44 constructors.
04:16:11 <elliott> lol
04:16:28 <Gregor> elliott: s/scratch/argument/ in fact :P
04:16:36 <elliott> Gregor: heh
04:16:52 <elliott> oerjan: i will probably try and abstract that out so it only needs one constructor per valid to/from pai :P
04:16:52 <elliott> r
04:16:54 <oerjan> i suppose your AllDirectionsBut is a must
04:16:57 <elliott> but yes, go on
04:17:17 <oerjan> well, i think that's most of it?
04:17:55 <elliott> hm
04:18:14 <Gregor> elliott: Fixt.
04:18:20 <elliott> oerjan: if I asked you how to implement "go west in currently-focused cursor" would you disown me?
04:18:48 <oerjan> maybe if you insisted on all the details
04:19:25 <elliott> heh
04:19:31 <elliott> oerjan: you navigate between cursors /spatially/ in this, right?
04:19:37 <elliott> that seems to make navigating in some other order a pain
04:19:54 <oerjan> well yeah?
04:20:26 <elliott> oerjan: well like i said, my IPs are used round-robinly :P
04:21:01 <oerjan> well yeah i didn't do any attempt to optimize that order
04:21:19 <oerjan> or any order, really
04:21:27 <elliott> oerjan: right
04:21:34 <elliott> oerjan: but i'm not sure how you do it at /all/
04:21:42 <elliott> it seems like you'd have to try every cursor until you found the one you care about
04:25:05 <oerjan> data MetaContext = MetaContext { nwNeighbor :: MetaCursor (To NW), ..., up :: MetaCursor dir, signPost :: SignPost } -- it occurs to me that some field name disambiguation will be needed
04:25:20 <oerjan> anyway, say that's the current focused context
04:25:46 <oerjan> first, look in the signPost to find out where the ip you want to be at is
04:26:17 <oerjan> if it's here, you're set...
04:26:24 <elliott> ah! right
04:26:30 <elliott> OK, that makes sense now
04:26:37 <elliott> how do you go east >:)
04:27:34 <oerjan> hm assuming you're focused at the ip...
04:27:41 <oerjan> look at the up
04:28:10 <elliott> oerjan: btw i am not looking forward to figuring out how to mutate within the 128x128 area :P
04:28:20 <elliott> I think I'll have to just check every other IP
04:28:31 <elliott> I don't really want to add caches to a structure this complex
04:28:35 <elliott> erm, as in
04:28:38 <elliott> because other IPs could be there too
04:28:50 <elliott> assuming that's actually possible with yours...
04:29:14 <oerjan> ah
04:30:45 <oerjan> oh hm
04:31:12 <oerjan> i have not properly considered the actual _leaf_ nodes, where the 128x128 data would reside
04:31:34 <oerjan> well except for the PlainCursor ones, but they don't contain real cursors
04:31:46 <elliott> so we have a zipper for trees with no top or bottom? :P
04:35:59 -!- madbr has left.
04:36:10 <Gregor> elliott: ARM goes all the way up to -O3 (with -fno-toplevel-reorder)
04:36:19 <elliott> X-D
04:37:02 <oerjan> MNLeaf :: { area :: Array "whatever", signPost :: SignPost } -> MetaNode (To dir)
04:37:14 <oerjan> may be what is needed
04:37:23 <elliott> Array "whatever"
04:37:25 <elliott> good array
04:37:33 <oerjan> best array
04:37:46 <elliott> oerjan: ok so what if i actually put this into a file and tried to make it all typecheck :P
04:38:14 <oerjan> well as i said i have not kept all field names distinct between data types, so fix that :P
04:39:40 <elliott> oerjan: ok [CRACKS KNUCKLES, PUTS BASEBALL CAP ON BACKWARDS, STARTS UP EMACS, CHEWS ON GUM, DISOWNS AUTHORITY + PARENTS] time to ROCK!!!!!!
04:39:43 <elliott> i am such a serious person
04:39:54 <variable> http://thc.org/root/phun/unmaintain.html
04:39:56 <variable> either that
04:40:02 <variable> or write all your code in INTERCAL
04:40:47 <elliott> oerjan: so wait, are plain [NW][SE] ever used, or is it always within either From or To now?
04:41:41 <elliott> er
04:41:44 <elliott> [NS][EW]
04:41:48 <Gregor> elliott: I can't get IOCCC 2001 bellard to run :(
04:41:59 <elliott> Gregor: Surprising :P
04:42:11 <oerjan> i cannot recall
04:42:31 <elliott> oerjan: oh you actually got the gadt record syntax almost right
04:42:33 <elliott> oerjan: Foo { ... } :: A
04:42:50 <oerjan> ah
04:42:51 <elliott> <oerjan> PlainCursor From{NW,NE,SW,SE} is basically our old Cursor and PlainCursor {NW,NE,SW,SE} is a QuadTree, i think
04:43:02 <elliott> oerjan: does that still use plain directions or is the QuadTree case in a To?
04:43:11 <oerjan> in a To
04:43:40 <elliott> oerjan: ok. now to find your old Cursor :P
04:43:40 <oerjan> so you don't need to list all
04:43:47 <elliott> unless you recall it :P
04:44:35 <oerjan> well it should be very similar to MetaNode
04:44:50 <oerjan> MetaNode (From ...)
04:44:50 <elliott> Nov 14 03:03:10 <oerjan>data QuadCursor t = FromNorth { southChild :: t, eastChild :: t, westChild :: t, up :: QuadCursor (QuadBranch t) } | FromSouth ...
04:44:58 <elliott> oerjan: is it just that but with NW/SE etc. instead of North/South?
04:45:27 <oerjan> that first one was in error, i corrected it to NW/SE later
04:45:56 <oerjan> well not _exactly_ that, it's all gadts now :P
04:47:07 -!- calamari has quit (Quit: Leaving).
04:47:53 <oerjan> PCFromNW { neNeighbor :: PlainCursor (To NE), swNeighbor :: ..., seNeighbor :: ..., up :: PlainCursor (From dir) } -> PlainCursor (From NW)
04:48:41 <oerjan> PCLeaf :: { area :: Array "whatever" } -> PlainCursor (To dir)
04:48:46 <oerjan> something like that
04:48:50 <elliott> oerjan: i'm on to PathNode, FWIW
04:49:07 <oerjan> ok
04:49:14 <elliott> oerjan: wait, what happened to the QuadTree case?
04:49:32 <elliott> <oerjan> PlainCursor From{NW,NE,SW,SE} is basically our old Cursor and PlainCursor {NW,NE,SW,SE} is a QuadTree, i think
04:49:54 <oerjan> PCTo :: { neNeighbor :: ..., ... } -> PlainCursor (To dir)
04:50:05 <oerjan> would be that and PCLeaf
04:50:11 <elliott> "However, for GADTs there is the following additional constraint: every constructor that has a field f must have the same result type (modulo alpha conversion)"
04:50:16 <elliott> boo, I need different field names for each signpost
04:50:20 <elliott> oerjan: ah, ok
04:50:27 <oerjan> darn :(
04:51:00 <oerjan> that sounds most annoying
04:51:10 <elliott> oerjan: is PCTo just PlainCursor (To dir) for each dir?
04:51:31 <elliott> also, I need a name for (From dir)/(To dir), like dir is for all the directions. origin?
04:51:31 <oerjan> um yes
04:51:56 <elliott> oerjan: not From? ok
04:52:27 <oerjan> i gave PCFromNW above, the rest of the Froms should be like that.
04:52:32 <elliott> right
04:53:25 <elliott> oerjan: oh hm. (From foo)/(To foo) are directions
04:53:29 <elliott> it's the foos that need a name
04:53:34 <elliott> I...think?
04:53:37 <elliott> help :
04:53:38 <elliott> :(
04:53:48 <elliott> no, NW/SE/NE/SW are definitely directions, so I do need a name
04:54:11 <oerjan> heh
04:55:13 <elliott> oerjan: quick, name (From dir)/(To dir) :-(
04:56:18 <elliott> <oerjan> Direction would be a value form of the To dir, From dir things.
04:56:27 <elliott> aaaaargh, you've been calling both of them directions all this time
04:56:31 <elliott> oerjan you're awful :( but uh thanks
04:56:34 <oerjan> pretty much
04:57:09 <elliott> oerjan: come on come on gimme a name gimme a name :(
04:57:21 <oerjan> Exit
04:57:30 <elliott> ok
04:58:44 <elliott> oerjan: woo, just PathNode to go
04:59:30 <elliott> oerjan: hm MetaContext is new, right?
04:59:39 <elliott> <oerjan> MNLeaf :: { area :: Array "whatever", signPost :: SignPost } -> MetaNode (To dir)
04:59:45 <elliott> oerjan: er is this required as well as the leaf in PlainCursor?
05:01:21 <elliott> <oerjan> PN_ToNW_ToNW :: { neNeighbor :: PlainCursor (To NE) } -> { swNeighbor :: ... } -> { seNeighbor :: ... } -> PlainNode (To NW) (To NW)
05:01:21 <elliott> <oerjan> similarly for PN_To**_To**
05:01:25 <elliott> oerjan: the **s here have to be equal, right?
05:02:52 <elliott> agh
05:02:54 <elliott> <oerjan> PN_FromNW_FromNW :: { neNeighbor :: ..., swNeighbor :: ..., seNeighbor :: ... } -> PlainNode (From NW) (From NW)
05:03:02 <elliott> oerjan: and are these PlainCursor (To ...)s or PlainCursor (From ...)s?
05:03:04 <elliott> the neighbours, that is
05:03:19 <oerjan> elliott: yes, MNLeaf is for a leaf that is a virtual cursor
05:03:35 <oerjan> (which means it's a real one, if you don't have extraneous virtual ones)
05:03:39 -!- SgeoN1 has quit (Read error: Connection reset by peer).
05:03:58 -!- SgeoN1 has joined.
05:04:11 <oerjan> no, the **s don't have to be equal
05:04:48 <oerjan> they are PlainCursor (To ...)'s
05:04:51 <elliott> data PathNode src dest where
05:04:51 <elliott> PNToTo :: PlainCursorTosWithout2 a b -> PathNode (To a) (To b)
05:04:51 <elliott> PNFromFrom :: PlainCursorTosWithout2 a b -> PathNode (From a) (From b)
05:04:51 <elliott> PNFromTo :: PlainCursorTosWithout2 a b -> PlainCursor (From dir) -> PathNode (From a) (To b)
05:04:52 <elliott> there, I think
05:06:11 <oerjan> note that PNFromTo should have a /~ b
05:06:40 <elliott> oerjan: ... you realise expressing that constraint is a pain :P
05:06:49 <elliott> thankfully possible since we only have four directions...
05:07:01 <oerjan> yeah, you may consider it optional
05:07:27 <elliott> oerjan: hm would it be more convenient as a class constraint on the constructor, or as an actual type
05:07:34 <elliott> where the latter is a GADT
05:07:38 <elliott> with the obvious constructors
05:07:52 <elliott> (i'm thinking, for the operations on these)
05:10:12 <elliott> oerjan: ooh, convenient, all the "...s without dir" use (To dir) as the type argument >:)
05:10:25 <elliott> oerjan: ...i feel really bad about wanting to exploit this, but it's sort of integral to the nature of a neighbour right?! reassure me
05:15:44 <elliott> oerjan: um ok i need guidance
05:15:52 <elliott> oerjan: it would be really bad to save on constructors by having
05:15:56 <oerjan> hm?
05:16:02 <elliott> Foo :: NeighboursWithout2 t a b -> NeighbousrWithout2 t b a
05:16:03 <elliott> right? :p
05:16:09 <elliott> usage-wise
05:17:11 <elliott> oerjan: right?? :'(
05:17:21 <elliott> i already have
05:17:22 <elliott> Neighbours2Same :: Neighbours1 t dir -> Neighbours2 t dir dir
05:17:23 <elliott> :p
05:18:04 <oerjan> i think my brain is a bout fried for today
05:20:01 -!- oerjan has quit (Quit: Good night).
05:20:13 <elliott> psht!
05:21:38 -!- copumpkin has joined.
05:24:43 <Gregor> $ wc -c jitchards.c
05:24:43 <Gregor> 1984 jitchards.c
05:25:18 <elliott> Best filesize.
05:28:37 -!- nys has quit (Quit: night).
05:39:50 <shachaf> elliott: Did you ever answer my question about cookies?
05:39:58 <elliott> Which question?
05:40:00 <elliott> Oh, that lambdabot one?
05:40:08 <elliott> They're certainly not UK-cookies.
05:40:26 <shachaf> Do they exist in the UK?
05:41:13 <elliott> I've never come across one? I don't know that they don't, though.
05:41:20 <elliott> "Fortune cookies, while largely an American item, are occasionally seen in other countries, most often at Chinese restaurants. Fortune cookies have been distributed in Canada, the United Kingdom, Australia, New Zealand, India, Brazil, Mexico, France, The Netherlands and Germany."
05:41:39 <monqy> fortune cookies are weird
05:41:46 <monqy> I don't like them
05:42:07 <elliott> monqy: theyre ghosts (boo)
05:42:18 <monqy> :o
05:43:08 <elliott> Gregor: BTW, if all goes horribly wrong you might get an actual UMLBox user soon.
05:43:19 <elliott> Gregor: I've suggested it to the tup developer to solve a certain problem and he thinks it looks promising :P
05:51:58 <elliott> Hey shachaf! I'm going to make you look in the other direction again.
05:51:59 <elliott> *PSeq> :t pfoldr
05:52:00 <elliott> pfoldr
05:52:00 <elliott> :: (forall a b c. path a b -> result b c -> result a c)
05:52:00 <elliott> -> (forall a. result a a)
05:52:00 <elliott> -> PSeq path src dest
05:52:00 <elliott> -> result src dest
05:52:05 <elliott> Brought to you by the Power of unsafeCoerce(tm).
05:52:30 <shachaf> elliott: Beeping me in IRC has approximately the opposite effect, as you are well aware.
05:52:46 * shachaf is now blind.
05:52:47 <elliott> Yes, but it lets you know so that you can look away more /intentionally/.
05:53:08 <elliott> *PSeq> :t pfoldr (<|) empty
05:53:08 <elliott> pfoldr (<|) empty :: PSeq path src dest -> PSeq path src dest
05:53:08 <elliott> Wow, it actually works.
05:53:09 * shachaf doesn't know the context of elliott's type.
05:53:30 <elliott> Hmm, why don't Seqs have pfoldfromtheend?
05:53:35 <elliott> Er, without the p.
05:53:45 <shachaf> elliott: However, using type variable names longer than a single character is very unHaskelly of you.
05:54:35 <elliott> shachaf: Yeah, I got tired of it being unreadable. :-(
05:54:51 <elliott> data PViewL path src dest where
05:54:51 <elliott> PEmptyL :: PViewL path a a
05:54:51 <elliott> (:<) :: path src mid -> PSeq path mid dest -> PViewL path src dest
05:54:51 <elliott> It's pretty much sacrilege.
05:55:11 * shachaf wonders what elliott is doing but doesn't want to read backlog.
05:55:23 <shachaf> haskellworldproblems, eh?
05:55:43 <elliott> shachaf: (PSeq path src dest) is basically (path src a, path a b, path b c, path c d, path d dest).
05:55:49 <elliott> shachaf: Except an arbitrary number of those, obviously.
05:55:56 <elliott> And it's a Seq, so fast access from the end too.
05:56:22 <elliott> shachaf: It's used in oerjan's fancy n-cursor quadtree zipper construction.
06:07:11 <elliott> shachaf: ENJOY: http://hpaste.org/54095
06:07:21 <elliott> "is this correct?" -- yes it is, I'm an idiot.
06:11:28 <DCliche> there are two esolangs on the wiki named 'clue' but neither has to do with Clue/Cluedo
06:11:50 <DCliche> one should be made, where all legal syntax is of the form 'X, in the Y, with the Z'
06:12:15 <monqy> would it do anything interesting
06:12:45 <monqy> oh man what if it was an really verbosse brianfuck derivative
06:12:57 <monqy> equivalent
06:13:23 <shachaf> monqy: :-(
06:13:26 <monqy> thing in the thing with the thing -> a brainfuck comand,. depending on what the things are....
06:13:38 <shachaf> elliott: Look at what DCliche and monqy is doing.
06:13:40 <shachaf> s/is/are/
06:13:48 <elliott> shachaf: monqy is On Our Side, don't you worry.
06:13:53 <elliott> He is a True Patriot.
06:13:56 * shachaf isn't sure what Our Side is.
06:14:01 <monqy> true patriots side
06:14:07 * shachaf is not a true esolanger.
06:14:10 <elliott> Well, we don't like brainfuck derivatives much, I would suppose.
06:14:17 <DCliche> I was imagining one or more of them could be variables
06:14:25 <shachaf> The most esoteric language I know is, like, Haskell, man.
06:14:29 <DCliche> perhaps being vaguely similar to SPL
06:14:38 <monqy> is haskell esoteric.........
06:14:42 <shachaf> Fine, C++.
06:15:42 <shachaf> monqy: (I didn't say it was, anyway.)
06:15:51 <elliott> @tell Phantom__Hoover Check your lambdabot mail as Phantom_Hoover.
06:15:52 <lambdabot> Consider it noted.
06:15:55 <elliott> @tell Phantom_Hoover Say the following to lambdabot, please:
06:15:55 <lambdabot> Consider it noted.
06:16:28 <monqy> what does it take to know c++? (I may or may not know c++.)
06:16:30 <elliott> @tell Phantom_Hoover @tell elliott Hey, you should try and coerce the GHC API into doing that hole-checking thing sometime. By sometime, I mean now; past you gets to decide exactly when you do things, those are the rules.
06:16:30 <lambdabot> Consider it noted.
06:16:42 <elliott> Behold my @tell-myself-without-getting-lambdabot-to-bug-me-immediately-after mechanism.
06:17:13 <monqy> phantom_hoover best mechanism
06:17:27 <monqy> phantom "best mechanism" hoover
06:17:39 <elliott> Phecanism.
06:18:01 <shachaf> elliott: I doubt you're going to do it as soon as you get that message.
06:18:06 <shachaf> So you might as well not have done it at all.
06:18:22 <elliott> shachaf: The idea is mostly so that I don't forget about it.
06:18:31 <shachaf> @tell elliott Hey, you should try and coerce the GHC API into doing that hole-checking thing sometime. By sometime, I mean now; past you gets to decide exactly when you do things, those are the rules.
06:18:31 <lambdabot> Consider it noted.
06:18:37 <elliott> No.
06:18:38 <lambdabot> elliott: You have 1 new message. '/msg lambdabot @messages' to read it.
06:18:42 <elliott> See what you did?
06:19:23 <shachaf> @tell elliott Hey, you should try and coerce the GHC API into doing that hole-checking thing sometime. By sometime, I mean now; past you gets to decide exactly when you do things, those are the rules.
06:19:23 <lambdabot> Consider it noted.
06:19:30 * shachaf decides to stop.
06:19:32 <elliott> @tell shachaf u mad
06:19:32 <lambdabot> Consider it noted.
06:19:33 <elliott> @tell shachaf u mad
06:19:33 <elliott> @tell shachaf u mad
06:19:33 <elliott> @tell shachaf u mad
06:19:33 <lambdabot> Consider it noted.
06:19:33 <elliott> @tell shachaf u mad
06:19:33 <lambdabot> Consider it noted.
06:19:33 <elliott> @tell shachaf u mad
06:19:34 <lambdabot> Consider it noted.
06:19:34 <lambdabot> Consider it noted.
06:19:34 <lambdabot> Consider it noted.
06:19:38 <elliott> ENJOY, FRIEND
06:19:38 <lambdabot> elliott: You have 1 new message. '/msg lambdabot @messages' to read it.
06:19:42 <elliott> NOOOOOOOOOO
06:19:44 <elliott> @messagse
06:19:47 <elliott> @messages
06:19:48 <lambdabot> Maybe you meant: messages messages?
06:19:52 <lambdabot> shachaf said 24s ago: Hey, you should try and coerce the GHC API into doing that hole-checking thing sometime. By sometime, I mean now; past you gets to decide exactly when you do things, those are
06:19:52 <monqy> @messages
06:19:54 <lambdabot> the rules.
06:19:56 <lambdabot> You don't have any new messages.
06:20:04 <shachaf> Fine, fine I get it.
06:20:05 <monqy> the rules.
06:20:22 <shachaf> @remember monqy the rules.
06:20:32 <elliott> @remember monqy the rules.
06:20:32 <lambdabot> I will remember.
06:20:43 <shachaf> @forget monqy the rules.
06:20:44 <lambdabot> Done.
06:20:45 <shachaf> @quote monqy
06:20:45 <lambdabot> Plugin `quote' failed with: getRandItem: empty list
06:20:47 <shachaf> @quote monqy
06:20:47 <lambdabot> Plugin `quote' failed with: getRandItem: empty list
06:20:51 <shachaf> @quote ehird
06:20:51 <lambdabot> ehird says: 2009: The Year of the Combinatorial Explosion of Haskell Web Frameworks. Also, the Linux Desktop.
06:20:53 <elliott> @remember monqy the rules.
06:20:53 <lambdabot> It is forever etched in my memory.
06:21:04 <elliott> @quote ehird
06:21:05 <lambdabot> ehird says: 2009: The Year of the Combinatorial Explosion of Haskell Web Frameworks. Also, the Linux Desktop.
06:21:09 <elliott> @quote elliott
06:21:09 <lambdabot> elliott says: Only two things in the universe are certain: Death, and two of the libraries you've decided to use taking different types of ByteString.
06:21:12 <elliott> @quote elliott
06:21:13 <lambdabot> elliott says: i'm here to prove theorems and compile code and I'm all out of code
06:21:15 <elliott> @quote elliott
06:21:15 <lambdabot> elliott says: I have weird mental spheres that I divide all my coding into and that determine editor and the like
06:21:21 <elliott> What?
06:21:23 <elliott> @quote elliott
06:21:23 <lambdabot> elliott says: Top universities now employ people to watch infomercials all day to find the latest mysteries.
06:21:26 <elliott> @quote elliott
06:21:27 <lambdabot> elliott says: Only two things in the universe are certain: Death, and two of the libraries you've decided to use taking different types of ByteString.
06:21:32 <elliott> I have a lot of quotes.
06:21:38 <monqy> @quote monqy
06:21:39 <lambdabot> Plugin `quote' failed with: getRandItem: empty list
06:21:47 <DCliche> @quote Darth_Cliche
06:21:47 <lambdabot> No quotes match.
06:21:49 <elliott> @remember monqy the rules.
06:21:49 <lambdabot> It is forever etched in my memory.
06:21:53 <elliott> shachaf is a bad man.
06:21:55 <DCliche> @quote DCliche
06:21:56 <lambdabot> No quotes match. Maybe if you used more than just two fingers...
06:22:09 <monqy> @quote monqy
06:22:10 <lambdabot> Plugin `quote' failed with: getRandItem: empty list
06:22:14 <monqy> the rules...
06:22:36 <elliott> @remember monqy the rules.
06:22:36 <lambdabot> I will remember.
06:22:37 <elliott> @quote monqy
06:22:37 <lambdabot> monqy says: the rules.
06:22:48 <monqy> the rules.
06:22:50 <elliott> @tell Phantom_Hoover Remind me to "@remember monqy the rules." because shachaf is a bad person.
06:22:50 <lambdabot> Consider it noted.
06:22:57 <shachaf> :-(
06:22:58 <DCliche> @remember elliott @remember @remember @remember
06:22:59 <lambdabot> I will never forget.
06:23:00 <DCliche> @remember elliott @remember @remember @remember
06:23:00 <lambdabot> I will remember.
06:23:01 <DCliche> @remember elliott @remember @remember @remember
06:23:01 <lambdabot> Good to know.
06:23:02 <DCliche> @remember elliott @remember @remember @remember
06:23:02 <lambdabot> Okay.
06:23:05 <monqy> okay
06:23:05 <DCliche> @quote elliott
06:23:05 <elliott> That...
06:23:06 <lambdabot> elliott says: @remember @remember @remember
06:23:08 <elliott> No.
06:23:12 <elliott> @forget elliott @remember @remember @remember
06:23:12 <lambdabot> Done.
06:23:23 <shachaf> /nick Phantom_Hoover; /msg lambdabot @messages
06:23:28 <DCliche> elliott: Well, you keep spamming @remember
06:23:35 <shachaf> @forget elliott @remember @remember @remember
06:23:36 <lambdabot> Done.
06:23:37 <shachaf> @forget elliott @remember @remember @remember
06:23:37 <lambdabot> Done.
06:23:38 <shachaf> @forget elliott @remember @remember @remember
06:23:38 <elliott> DCliche: shachaf keeps spamming @forget. In PRIVATE.
06:23:39 <lambdabot> Done.
06:23:47 <shachaf> elliott: That ain't spamming!
06:23:50 <DCliche> elliott: Not as annoying as publically ;p
06:24:03 <elliott> @forget DCliche
06:24:03 <lambdabot> Incorrect arguments to quote
06:24:07 <elliott> @forget DCliche forever
06:24:07 <lambdabot> No match.
06:24:27 <DCliche> @quote shachaf
06:24:27 <lambdabot> shachaf says: We used to have a big collection of them but most of them got wiped in the Great Lambdabot Wipe of Every Few Months.
06:24:33 <DCliche> @quote elliott
06:24:34 <lambdabot> elliott says: Top universities now employ people to watch infomercials all day to find the latest mysteries.
06:25:31 <monqy> @quote monqy
06:25:31 <lambdabot> Plugin `quote' failed with: getRandItem: empty list
06:25:44 <elliott> shachaf you are scum.
06:25:47 <elliott> AND I AM LEAVING.
06:25:51 -!- elliott has quit (Quit: Leaving).
06:26:01 <shachaf> Aw, and I was about to start singing.
06:26:14 <monqy> scum songs
06:26:22 -!- elliott has joined.
06:26:26 <monqy> hi
06:26:30 <shachaf> monqy and the rules. monqy and the rules. It's monqy, it's monqy and the rules rules rules rules...
06:26:40 <elliott> NOTE TO SELF:
06:26:41 <elliott> newtype SupplyT s m a = SupplyT { unSupplyT :: (forall r. (s -> SupplyT s m r) -> SupplyT s m r) -> m a }
06:26:45 -!- elliott has quit (Client Quit).
06:26:48 <monqy> bye
06:27:01 <shachaf> @tell elliott newtype SupplyT s m a = SupplyT { unSupplyT :: (forall r. (s -> SupplyT s m r) -> SupplyT s m r) -> m a }
06:27:04 <lambdabot> Consider it noted.
06:27:17 <DCliche> @quote elliott
06:27:22 <lambdabot> elliott says: @remember @remember @remember
06:27:39 <monqy> remember remember remember: never forget
06:27:56 <shachaf> @forget elliott @remember @remember @remember
06:27:56 <lambdabot> Done.
06:28:00 <monqy> rip
06:28:04 <monqy> @quote elliott
06:28:04 <lambdabot> elliott says: I have weird mental spheres that I divide all my coding into and that determine editor and the like
06:28:14 <monqy> how is that a quote...
06:28:33 <DCliche> @quote DCliche
06:28:34 <lambdabot> DCliche says: @remember elliott @remember @remember @remember
06:28:41 <monqy> good quote
06:29:40 <Patashu> @quote Patashu
06:29:41 <lambdabot> No quotes match. This mission is too important for me to allow you to jeopardize it.
06:29:47 <Patashu> rofl
06:30:25 <shachaf> DCliche: How many times did you @remember that?
06:30:32 <DCliche> @remember what
06:30:32 <lambdabot> Incorrect arguments to quote
06:30:49 <shachaf> DCliche: elliott @remember @remember @remember
06:31:15 <DCliche> I'll be back in half an hour or so, I need to count
06:35:53 <DCliche> 46 apparently, not as many as I expected
06:36:19 <DCliche> @quote lambdabot
06:36:19 <lambdabot> lambdabot says: Done.
06:36:22 <DCliche> @quote lambdabot
06:36:23 <lambdabot> lambdabot says: why on the earth whould I slap dons with a wet trout
06:42:22 -!- DCliche has quit (Quit: You are now graced with my absence.).
06:47:55 <pikhq> https://upload.wikimedia.org/wikipedia/commons/2/23/Xiaoerjing-Ekzemplafrazo.svg Anyone care to guess the language? (note: I can just about guarantee you'll get it wrong)
06:56:52 <shachaf> pikhq: The filename is a bit of a hint.
06:56:57 <pikhq> shachaf: Is it?
06:57:31 <pikhq> Well. I suppose it is.
06:58:05 <shachaf> I guessed that "Xiaoerjing" was vaguely Chinese-related before looking it up.
06:58:16 <pikhq> Still, WTF.
06:58:47 <shachaf> ?
06:59:11 <pikhq> That's fucking Mandarin, the fuck.
07:07:57 <copumpkin> western china?
07:20:12 -!- GreaseMonkey has quit (Quit: The Other Game).
07:42:27 <fizzie> I would have guessed that "Xiaoerjing" would be vaguely oerjan-related.
07:43:48 -!- Zuu has quit (Read error: Connection reset by peer).
07:45:59 -!- SgeoN1 has quit (Ping timeout: 240 seconds).
07:48:51 -!- Zuu has joined.
08:21:03 -!- CakeProphet has joined.
08:21:03 -!- CakeProphet has quit (Changing host).
08:21:03 -!- CakeProphet has joined.
08:32:04 <CakeProphet> fungot
08:32:06 <fungot> CakeProphet: madam president, may i offer my congratulations on his excellent report inviting us to reflect a vision of the future constitutional treaty. yet again we are suffering from this. allow me to intervene in this region where there is overcapacity, fishermen who can no longer stand by while saddam hussein keeps playing these games. last month the commission presented its legislative proposals for the 18 council regulat
08:33:37 <CakeProphet> ^style
08:33:37 <fungot> Available: agora alice c64 ct darwin discworld europarl* ff7 fisher fungot homestuck ic irc iwcs jargon lovecraft nethack pa sms speeches ss wp youtube
08:33:55 <CakeProphet> ^style speeches
08:33:56 <fungot> Selected style: speeches (misc. speeches from Project Gutenberg)
08:33:57 <CakeProphet> fungot: hi
08:34:04 <CakeProphet> fungot: why do you not love me? :(
08:34:10 -!- CakeProphet has changed nick to ElliotDrone1.
08:34:14 <ElliotDrone1> fungot: hi
08:34:15 <fungot> ElliotDrone1: mr. chairman and fnord am very glad to be able to violate the ordinary rules of composition as well as society has its pleasures; as from the city.
08:34:18 -!- ElliotDrone1 has changed nick to CakeProphet.
08:42:31 <CakeProphet> fungot: oh?
08:42:32 <fungot> CakeProphet: if i had written it all out the day before the furnace, so a fancy may be said that a man who had neglected his studies were fnord by the restless bed of fnord and i recollect that the most audacious libels on royal majesty have passed without notice; that the most audacious libels on royal majesty have passed without notice; that the most intense terrors."
09:17:53 -!- monqy has quit (Quit: hello).
10:04:00 -!- hagb4rd has joined.
10:42:30 -!- copumpkin has quit (Ping timeout: 248 seconds).
10:42:55 -!- copumpkin has joined.
11:05:21 -!- derdon has joined.
11:43:08 -!- aloril has quit (Ping timeout: 240 seconds).
11:56:31 -!- aloril has joined.
12:21:30 -!- augur has quit (*.net *.split).
12:21:31 -!- twice11 has quit (*.net *.split).
12:21:31 -!- yorick has quit (*.net *.split).
12:21:57 -!- augur has joined.
12:24:06 -!- twice11 has joined.
12:24:43 -!- yorick has joined.
12:55:52 -!- boily has joined.
13:04:05 -!- pikhq_ has joined.
13:04:24 -!- pikhq has quit (Ping timeout: 258 seconds).
13:25:32 -!- Patashu has quit (Ping timeout: 240 seconds).
13:35:26 -!- Phantom_Hoover has joined.
13:37:59 -!- copumpkin has quit (Ping timeout: 248 seconds).
13:38:23 -!- copumpkin has joined.
13:44:22 -!- MSleep has quit (*.net *.split).
13:44:22 -!- Zwaarddijk has quit (*.net *.split).
13:48:30 -!- MSleep has joined.
13:48:30 -!- Zwaarddijk has joined.
14:04:40 -!- copumpkin has quit (Ping timeout: 252 seconds).
14:05:04 -!- copumpkin has joined.
14:29:02 -!- Zwaarddi1k has joined.
14:33:47 -!- MSleep has quit (*.net *.split).
14:33:47 -!- Zwaarddijk has quit (*.net *.split).
14:52:24 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:08:27 <tswett> fungot: is it okay if I pretend to have a conversation with you?
15:08:29 <fungot> tswett: there is one honest and industrious neighbours rather than among rioters and vagabonds. this matter is as much a theory of government in opposition to their prayer. when the question is not, i am fnord. fnord patron ( rousseau) et fnord fnord quod fnord urbi.
15:08:49 <tswett> Uh...
15:08:50 <tswett> ^style
15:08:50 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher fungot homestuck ic irc iwcs jargon lovecraft nethack pa sms speeches* ss wp youtube
15:08:56 <tswett> Is that so.
15:09:03 <tswett> ^style ss
15:09:04 <fungot> Selected style: ss (Shakespeare's writings)
15:09:12 <tswett> Mm, no.
15:09:21 <tswett> ^style homestuck
15:09:21 <fungot> Selected style: homestuck (Homestuck pages 1901-4673)
15:09:29 <tswett> fungot: no spoilers, please.
15:09:30 <fungot> tswett: the only sad part is how easy it's going to be a long day. though it is pretty conceivable that i will remain an impeccable leader for a span. he is the first and they get progressively more difficult to reach a very high rolls he was lucky. my lusus sucks, what a terrible idea. leave me alone.
15:09:41 -!- derrik has joined.
15:10:01 <tswett> fungot: oh, come on. You're a terrible leader and you deserve to have such a sucky lusus.
15:10:01 <fungot> tswett: john, try to stop me i dare you. published by major developers, was given a name! you've been eating it all day. and it might help you take a picture of a fella all worked! you love your scribblepad.
15:10:54 <tswett> fungot: I guess I will, then. Even my scribblepad easily matches you... what kind of lame weapon do you have allocated, anyway?
15:10:55 <fungot> tswett: this is it, like an apple or that it is your backup hat. problem solved, you guess. at the last minute she flung through skaian defense. what a royal mess of his lovely new horseleather bib. it just so happens that today, the 13th of april. another day of uneventful but highly satisfying
15:11:01 <Phantom_Hoover> fizzie, how does it feel to be a major developer?
15:11:02 <lambdabot> Phantom_Hoover: You have 4 new messages. '/msg lambdabot @messages' to read them.
15:11:23 <tswett> An apple. Yes, I can surely defeat someone armed with only an apple.
15:12:08 <Phantom_Hoover> What if they're armed with that sword alone?
15:15:49 <tswett> What sword?
15:17:32 -!- copumpkin has joined.
15:33:27 <Phantom_Hoover> tswett, that sword alone!
15:33:36 <Phantom_Hoover> It can't stop, you know.
15:34:21 <tswett> I'm afraid I'm not familiar with the sword you speak of.
15:53:49 -!- MDude has joined.
15:56:46 <Gregor> HEY GUYYYYYYS best VAX simulator?
16:06:38 -!- sebbu2 has joined.
16:08:49 -!- sebbu has quit (Ping timeout: 276 seconds).
16:17:59 -!- elliott has joined.
16:21:03 <elliott> 08:34:10: -!- CakeProphet is now known as ElliotDrone1.
16:21:04 <lambdabot> elliott: You have 2 new messages. '/msg lambdabot @messages' to read them.
16:21:04 <elliott> CakeProphet: die
16:28:39 <elliott> 15:56:46: <Gregor> HEY GUYYYYYYS best VAX simulator?
16:28:41 <elliott> Gregor: Dyson?
16:28:49 <elliott> Good ol' Phantom_Hoover here?
16:28:57 <elliott> Gregor: MORE SERIOUSLY, probably SIMH?
16:29:01 <elliott> Top on Google.
16:29:06 <elliott> Also it does PDPs.
16:29:35 <Phantom_Hoover> You can tell it's good because it's unpronounceable.
16:29:48 <Phantom_Hoover> Wait, my name has an mh in it...
16:32:09 <Phantom_Hoover> (I tried to change my name to Ford_Prefect here, and then to Ix, but they're both in use.)
16:37:14 <Phantom_Hoover> "Note that the K combinator is operationally similar to \x y . x" — Haskell wiki.
16:37:18 <Phantom_Hoover> Similar?
16:38:17 <elliott> Phantom_Hoover: SKI calculus isn't defined in terms of the lambda-calculus.
16:38:33 <Phantom_Hoover> Sure, but operationally they're identical.
16:39:09 <elliott> Well, yes.
16:39:20 <elliott> Phantom_Hoover: But you have to define a system with both of 'em to say things like that.
16:39:29 <elliott> Otherwise it's not clear what "identically" means at all.
16:40:45 <Phantom_Hoover> Oh god, I nearly used a hyphen rather than a diaeresis.
16:40:54 <elliott> You almost weren't terrible.
16:41:14 <Phantom_Hoover> I WILL TAKE MY DIAERESES TO THE GRAVE
16:42:07 <elliott> Diaeresae.
16:42:12 <Phantom_Hoover> Sorry, Ï WÏLL TÄKË MŸ DÏÄËRËSËS TÖ THË GRÄVË
16:43:13 <elliott> Phantom_Hoover: Ah.
16:44:41 <Deewiant> s/W/Ẅ/g;s/H/Ḧ/g
16:45:12 <Phantom_Hoover> I was going to try them on all the consonants, but I couldn't be bothered.
16:46:36 <elliott> Deewiant: Hey WISE GUY, I've got a TEAM OF PHDS working on my N-CURSOR ZIPPER SPARSE DISCERETE INFINITE LAHEY-SPACE INTERFACE
16:46:39 <elliott> SO HA HA HA
16:47:19 <Deewiant> Hope it works out for you
16:47:49 <elliott> Deewiant: I'VE USED ABOUT SEVEN GADTS AND UNSAFECOERCE, IT FUCKING BETTER
16:54:33 <Gregor> elliott: YeahOK, SIMH seems like the way. Unfortunately PDP's will never be supported, I need too much memory :P
16:54:39 <elliott> lol
16:54:54 <elliott> Gregor: So, three kilobytes?
16:55:46 <Gregor> I haven't measured, actually :P
16:55:50 <Gregor> But probably ~10M
17:00:01 <Gregor> elliott: Anyway, I feel VAX would be a nice topper for my JIT :P
17:00:42 <elliott> Gregor: I can't help but feel you'd do better if your language was less boring :P
17:00:52 <Gregor> That's a point ...
17:00:55 <Gregor> What shall I add?
17:01:17 <elliott> I'd think more along the lines of "change" than "add", but that's probably way too much work at this point :P
17:01:30 <elliott> But a lot of the winning IOCCC entries do something fairly impressive even apart from their code.
17:01:35 <elliott> You still deserve to win though :P
17:01:56 <Gregor> I think the "fairly impressive" part is that it JITS EVERYWHERE :P
17:02:13 <elliott> Well, yeah, but you can't tell that just from running it, and it's no flight sim :P
17:02:26 <elliott> BTW you should integrate this technology into Fythe! :p
17:02:34 <Gregor> lol
17:05:56 -!- quintopia has quit (Ping timeout: 260 seconds).
17:15:54 -!- quintopia has joined.
17:15:54 -!- quintopia has quit (Changing host).
17:15:54 -!- quintopia has joined.
17:19:28 -!- monqy has joined.
17:21:50 <elliott> hi monqy
17:24:11 -!- Zuu has quit (Ping timeout: 244 seconds).
17:29:28 -!- augur has quit (Remote host closed the connection).
17:33:28 <elliott> Deewiant: BEHOLD YOUR DEFEATER: http://sprunge.us/MfXU
17:34:21 <Deewiant> It has been beheld
17:35:09 <elliott> Deewiant: There is noooo way you properly beheld that in the time it took you, did you even NOTICE the unsafeCoerce?
17:35:12 <elliott> The rank-2 fold??
17:35:27 <Deewiant> I missed the unsafeCoerces, noticed the fold though
17:37:38 <monqy> hi
17:38:30 <elliott> hi monqy you behold too http://sprunge.us/MfXU
17:38:47 <elliott> Deewiant: Also this is only a quadtree, it's going to require something even more ridiculously involved for something decent :-/
17:39:00 <elliott> Plus the fact that I don't actually have the algorithms to move the cursors about yet
17:39:01 <Deewiant> May I recommend a bucket PR-CIF k-d tree
17:39:39 <elliott> Deewiant: Maybe
17:39:51 <elliott> Deewiant: I'd rather not use something that wants a dynamic array, at least
17:40:05 <elliott> Also I'll have to use something slightly different from anything you say to establish my superior thinking
17:40:17 <elliott> Actually hmm
17:40:25 <elliott> Deewiant: You use a dynamic array just so you can load the whole file into one, don't you
17:40:27 <elliott> That's sneaky
17:40:29 <elliott> Sneaky and deceitful
17:41:17 <Deewiant> I can't do that since the file isn't rectangular
17:41:28 <elliott> Deewiant: I don't mean directly
17:41:38 <elliott> Deewiant: I just mean, you do it so that you don't have to deal with cross-array boundaries during file loading
17:41:39 <Deewiant> Then yes
17:41:46 <elliott> Sneaky, and wrong
17:42:10 <Deewiant> Well, in a sense I have to deal with them, if there're arrays already there
17:42:41 <elliott> Deewiant: Well, yes, but it still speeds up your initial load
17:43:04 <elliott> I guess I'll have to resolve myself to being slower on Mycology and faster on Fungicide
17:43:08 <elliott> s/resolve/resign/
17:43:15 <Deewiant> Compared to something like a hash table, it should, yes
17:43:57 <elliott> Deewiant: Compared to the structure you have but with fixed-size arrays :P
17:44:58 <Deewiant> Compared to that too, it should, yes
17:45:12 <Deewiant> The whole point was to not use fixed-size arrays :-P
17:45:33 <Deewiant> Until it turned out that not having the compiler optimize x*C into a shift-and-add was a bottleneck
17:46:56 <elliott> Deewiant: I don't see how dynamic arrays really help much, if you have a fancy k-d tree
17:47:03 <elliott> Or other sufficiently smart space :P
17:47:10 <elliott> Certainly the indexing is a lot more trivial
17:47:54 <Deewiant> Maybe they don't, it was more of a matter of principle
17:48:08 <elliott> lol
17:48:43 <elliott> Deewiant: Thankfully I think this n-cursor setup doesn't actually really have that much overhead over mutation, so ha
17:49:25 <elliott> (It basically cuts off the tree at each point where a cursor is, zips those at the cursor, and then arranges the whole thing into a zipper)
17:49:27 <elliott> (Sort of)
17:49:31 <Deewiant> Point being to one-up cfunge's "lol here's a int[1024*256], turns out it's fast to do stuff in that" with "I have no constants in my funge-space implementation and it's faster than yours"; unfortunately that didn't quite work (see x*C optimization)
17:49:51 <elliott> Heh
17:50:14 <elliott> Deewiant: You're still slower on Mycology, right :-)
17:50:17 <Deewiant> (And there were and still are other, different constants)
17:50:22 <Deewiant> elliott: AFAIK I'm faster on everything
17:50:43 <Deewiant> On full Mycology, I might be somewhat slower only due to executing more fingerprint tests
17:50:45 <elliott> How the heck do you beat it on Mycology; just your ridiculous fingerprint and stack microoptimisations?
17:50:54 <elliott> It's not like your fungespace will help any :P
17:51:17 <Deewiant> My fungespace is effectively the same and other than that, maybe those play a part, dunno :-P
17:54:33 <Deewiant> Actually, I think I'm still slower on fungot's underload interpreter; can't remember for sure
17:54:33 <fungot> Deewiant: that is a winner's attitude, and there is no particularly good human translation for this concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear concept. a concept usually denoted by a single, linear c
17:55:08 <elliott> :D
17:56:37 <elliott> Deewiant: What you need to do is implement UNDL
17:56:47 <elliott> For AUA (Advanced Underload Acceleration(tm))
17:59:37 <elliott> Deewiant: I... why am I actually considering implementing that
17:59:55 -!- augur has joined.
18:01:15 <Deewiant> Couldn't say
18:16:15 <elliott> "Here is a PoC for four new buffer overflows in GIMP. Compile it
18:16:15 <elliott> with open-cobol."
18:16:20 <elliott> Now that's what I like to hear.
18:17:03 <elliott> Hmph, it's not proper COBOL.
18:17:07 <elliott> It's just a glorified cat.
18:17:10 <elliott> Without the loop.
18:31:27 <Gregor> elliott: cat repl.jch hello.jch gorepl.jch | ./jitchards
18:31:31 <Gregor> Hello, world!
18:31:37 <elliott> Gregor: Wow :P
18:31:45 <elliott> Gregor: It's... not a repl without a prompt, y'know :P
18:31:47 <elliott> Also, what's gorepl.
18:32:08 <Gregor> elliott: 1) It has a prompt, I'm just suppressing it by catting shit in, 2) gorepl says "now run the function you loaded as main"
18:32:21 <elliott> Gregor: Wait, it /detects whether stdin is a tty/?
18:32:27 <Gregor> No
18:32:35 <Gregor> You'd have to cat repl.jch - | ./jitchards normally
18:32:41 <elliott> How does it suppress the prompt then :P
18:32:56 <Gregor> Oh, you mean it would show a 'put ur code here lol> ' thing
18:33:01 <Gregor> Well that's boring and stupid.
18:33:09 <elliott> Gregor: Don't call it a REPL then :P
18:33:17 <Gregor> FINE, I'LL ADD A PROMPT
18:33:22 <Gregor> !bf_txtgen >
18:33:27 <EgoBot> ​34 ++++++++++[>++++++>+>><<<<-]>++.>. [55]
18:33:30 <elliott> Gregor: You might also want to add the "read" and "loop" part so you don't have to cat - :-)
18:33:42 <elliott> I GUESS you can forego a tape debug output?
18:33:49 <Gregor> The whole system only reads from stdin, and it does loop X_X
18:33:58 <elliott> Gregor: Don't use bf_txtgen for single chars
18:34:09 <elliott> http://esolangs.org/wiki/Brainfuck_constants
18:34:12 <elliott> > ord '>'
18:34:13 <lambdabot> 62
18:34:14 <Gregor> elliott: It's two chars
18:34:21 <elliott> ++++[>+<++++]>-
18:34:30 <Gregor> elliott: It's two chars
18:34:32 <elliott> > ord ' '
18:34:34 <lambdabot> 32
18:34:40 <elliott> ++++[>+<++++]>-.[-]++++[>++++++++<-]>.
18:34:44 <elliott> ...OK, I guess bf_txtgen wins this time :P
18:34:46 <Gregor> Congrats, it's longer.
18:35:05 <Gregor> HEYWAIT
18:35:14 <Gregor> REPL = Read Eval Print Loop THERE IS NO "PROMPT" HERE
18:35:35 <quintopia> what
18:35:35 <elliott> No, there isn't, but every REPL in the history of ever has had a prompt.
18:35:38 <quintopia> yes
18:35:38 <Gregor> My repl is 100% REPL satisfaction except for the P :P
18:35:48 <quintopia> REPL should print a prompt
18:35:52 <quintopia> its userfriendly
18:35:54 <Gregor> Oy vey
18:36:02 <elliott> Gregor: R, E, P, L are necessary but not sufficient conditions :P
18:40:39 <Gregor> ... lol bf_txtgen ignored my space and put a newline :P
18:47:29 <elliott> Gregor: I bet EgoBot is the one ignoring the space :P
18:47:41 <Gregor> Probably
18:59:54 <elliott> 04:25:05: <oerjan> data MetaContext = MetaContext { nwNeighbor :: MetaCursor (To NW), ..., up :: MetaCursor dir, signPost :: SignPost } -- it occurs to me that some field name disambiguation will be needed
19:00:00 <elliott> well this is going to need oerjisambiguation >:(
19:00:33 <Gregor> elliott: lullll my circularity changes broke SPARC somehow :P
19:00:41 <elliott> lol
19:00:49 <elliott> Gregor: Did you ever get it working on Itanium
19:00:57 <Gregor> elliott: I don't have a working simulator.
19:01:05 <elliott> Gregor: MMIX?
19:01:17 <Gregor> elliott: Now there's a nice'n 8-D
19:01:34 <elliott> Gregor: Test with jsmmix :P
19:01:34 <Gregor> elliott: Except I have no stdlib, so can't really test >_>
19:01:49 <elliott> Gregor: More seriously, Alpha?
19:02:12 <Gregor> elliott: IIRC the only reason I haven't tried Alpha is that I was too lazy to build a cross compiler.
19:02:19 <elliott> X-D
19:07:33 <elliott> Argh, I forgot how awful GHC's API is.
19:12:20 <Gregor> elliott: Fixed SPARC.
19:12:26 <elliott> Woot
19:13:50 <Gregor> The problem was very stupid, it was variable shadowing :P
19:14:00 <Gregor> I didn't think it was so sensitive to this kind of change X-D
19:15:01 <Gregor> | | Target Architecture (alpha) ---> | |
19:15:05 <Gregor> | | Bitness: (32-bit) ---> | |
19:15:08 <Gregor> Uhhh, crosstool-ng?
19:15:12 <Gregor> alpha ain't gonna be 32-bit
19:21:19 <elliott> Deewiant: So does mushspace do k-d things or is it just capable of doing so without API changes in the future
19:21:33 <Deewiant> It should be capable
19:21:41 <Deewiant> mushspace == CCBI
19:22:22 <elliott> Deewiant: Right, just checking that it won't speed things up massively in the short term before Shiro takes the lead :P
19:36:11 -!- ais523 has joined.
19:36:48 <elliott> hi ais523
19:37:25 <ais523> hi elliott
19:38:54 <ais523> http://sprunge.us/AXOB
19:40:06 <ais523> elliott: ^
19:40:38 <elliott> ais523: glanced at file list, eyes hit upon the source directory, tab closed
19:40:44 <ais523> haha
19:40:46 <Gregor> OK, wtf variant of the Alpha do I need to select X_X
19:40:55 <elliott> call of link remains. perhaps this is the end...
19:41:18 <ais523> elliott: don't worry, it's sane
19:41:23 <ais523> it's only very tangentially related to Feather
19:41:29 <ais523> the name of the language is Not Even Feather
19:41:33 -!- CakeProphet has quit (Read error: Operation timed out).
19:41:36 <elliott> ais523: That's, uh, a very minimal syntax.
19:41:43 <ais523> yep
19:41:45 <ais523> it's just sexps
19:41:48 <ais523> those are really easy to parse
19:41:48 <elliott> ais523: Actually I think it shares a syntax with Qq.
19:41:58 <elliott> s/Qq/qq/
19:42:03 <ais523> the parser would be even simpler if I didn't try to do type inference in it
19:42:16 <elliott> `addquote <ais523> the parser would be even simpler if I didn't try to do type inference in it
19:42:23 <HackEgo> 719) <ais523> the parser would be even simpler if I didn't try to do type inference in it
19:42:57 <elliott> ais523: hmm, is it sufficiently Not Feather that my apparent inability to find any self-modification is expected?
19:43:20 <ais523> yes
19:43:25 <ais523> it doesn't have self-modification
19:43:52 <elliott> ais523: how is it Not Entirely Not Feather, then?
19:43:53 <ais523> NEF's a language designed for use as the backend of Feather interpreters
19:43:56 -!- Darth_Cliche has joined.
19:44:01 <elliott> ah
19:44:03 <elliott> is it complete?
19:44:06 <ais523> it's TC
19:44:17 <ais523> although a little tricky to avoid writing infinite loops in it
19:44:25 <elliott> I mean, is further expansion planned?
19:44:41 <elliott> also, someone should write a safe unsharchiver
19:44:45 <ais523> no, unless I find a good way to make evaluation less eager
19:44:50 <elliott> like how JSON was originally parsed with eval() and then people wrote real parsers
19:45:10 <elliott> ais523: grrr, sharbomb
19:45:17 <ais523> sorry; aren't they usually?
19:45:20 <elliott> maybe
19:45:32 <ais523> anyway, the main weird feature of the language is "overeager" evaluation
19:45:44 <elliott> ais523: is that the same as superstrict?
19:45:48 <elliott> i.e. doing reduction inside lambdas
19:45:53 <ais523> yep
19:45:54 <elliott> (which tends to make things like Y diverge)
19:46:12 <elliott> ais523: hmm, I think reimplementing this would be simpler than installing an OCaml compiler
19:46:16 * elliott does so
19:46:22 <Gregor> configure: error: The alphaev6 is not supported.
19:46:23 <Gregor> WTF GLIBC
19:46:31 <ais523> what, reimpls, or installs OCaml?
19:46:32 <Gregor> It said that for alphaev4, alphaev5 too
19:46:35 <elliott> ais523: former
19:46:39 <ais523> heh
19:46:58 <ais523> it's mostly a proof-of-concept interp
19:47:14 <elliott> ais523: hmm, what's the difference between Var1 and Var2?
19:47:16 <ais523> anyway, what I really need to show that NEF has fit its concept correctly is to write a self-interp with eigenratio 1
19:47:33 <ais523> elliott: which argument it refers to
19:49:19 <ais523> the language has exactly two types: 1, which takes an argument of type 2, and 2, which takes two arguments, of type 2 and 1 respectively
19:49:40 <ais523> functions never return, so it doesn't make sense to say that the return value has a type
19:50:05 <ais523> elliott: are you at least reimplementing it in Haskell?
19:50:56 <ais523> it should be possible to translate more or less directly, as apart from the I/O right at the start and some debug output, that interpreter is pure
19:51:37 <elliott> back
19:51:44 <elliott> ais523: yep
19:51:54 <elliott> ais523: so is Var1 a variable reference to a variable of type 1?
19:52:04 <ais523> yep
19:52:18 <elliott> ais523: cool, I can represent the types in Haskell then
19:52:43 <elliott> ais523: hmm, and Call1 calls a 1 with a 2?
19:52:50 <elliott> and Call2 calls a 2 with a 2 and a 1?
19:53:13 <ais523> Call2 takes three arguments; the first is the variable holding the function to call (of type 1), and the other two are its arguments, of types 2 and 1 respectively
19:53:17 <ais523> *(of type 2)
19:53:20 <ais523> and Call1 is analogous
19:53:23 <elliott> ais523: why can't the function be an expression instead?
19:53:26 <elliott> is that fundamental?
19:53:33 <ais523> that's the main unusual feature of NEF
19:53:36 <elliott> right
19:53:54 <elliott> ais523: what is the return type of a 1?
19:53:56 <elliott> and a 2?
19:54:00 <elliott> or can they return either 1s or 2s?
19:54:00 <ais523> there isn't one, they never return
19:54:07 <ais523> no function ever returns in NEF
19:54:12 <elliott> ais523: well, OK, what is the type of 2(2,1)?
19:54:16 <elliott> erm
19:54:17 <ais523> there isn't one
19:54:20 <elliott> where i use integers to mean "something of that type"
19:54:28 <elliott> ais523: then how do you pass a 2 or a 1?
19:54:35 <elliott> by getting it from a variable?
19:54:39 <elliott> if so, surely it should be Call1 of (int * int)
19:54:41 <ais523> either that, or by giving a template
19:54:44 <elliott> and Call2 of (int * int * int)
19:54:50 <elliott> ais523: that's not in the program type :)
19:54:59 <ais523> let me try to explain the language, rather than you to reverse-engineer it from the impl
19:55:10 <elliott> probably a good idea
19:55:24 <ais523> basically, if I write (a b c), that can be interpreted as \0.a(b,c)
19:55:35 <ais523> well, \-1.a(b,c)
19:55:38 <ais523> the numbers are relative to parens
19:55:44 <ais523> so (0 0) = \x.x
19:55:50 <ais523> wait
19:55:50 <elliott> ais523: is it de bruijn or reverse de bruijn?
19:56:08 <ais523> umm, I forget which way is which
19:56:26 <ais523> but (0 0) always means \v c.c(v)
19:56:35 <elliott> ais523: in de bruijn, 0 is the innermost var
19:56:39 <elliott> in reverse de bruijn, 0 is the outermost
19:56:43 <elliott> (de bruijn is much nicer)
19:56:55 <ais523> and likewise, (0 (0 1)) means \x c.c(\y d.d(x))
19:56:59 <ais523> so 0 is innermost
19:57:48 <ais523> forward de bruijn, then
19:59:13 <elliott> ais523: but, ehh, is the only reason you have the arguments be programs instead of variable numbers so that you can use Exit and Error there?
19:59:22 <elliott> or can you actually nest calls and that's what this template stuff is?
19:59:48 <ais523> elliott: it's basically the same as giving a literal lambda as an argument to something
19:59:57 <ais523> i.e. the arguments are either variables or function literals
20:00:07 <ais523> and function literals can be very complex
20:00:20 <ais523> (by "variable" I mean "lambda variable", btw, not the assignable sort)
20:00:22 <elliott> ais523: OK, let me get a straight answer: is Call1 (n, Call2 ...) ever valid?
20:00:34 <ais523> yes
20:00:42 <ais523> so is Call1 (n, Call1 …)
20:00:43 <elliott> ais523: what about Call1 (n, Call1 ...)?
20:00:45 <elliott> OK
20:01:00 <elliott> then indeed, i do not understand the language :)
20:01:16 <ais523> I have a few examples
20:02:04 <ais523> (0 0) is how you compile i into NEF; (0 (0 1)) acts like k; (0 (0 (2 0 (2 1 (1 0 2))))) acts like s; (0 (1 0) 0) acts like call/cc
20:02:21 <Gregor> elliott: Ohhey, it works on PPC and I never even did any work to make it, err, work there.
20:02:21 <elliott> I get I and K but not the others, although S looks familiar
20:02:28 <elliott> I think implementing it will probably be the first step in understanding it; it tends to be with languages this simple
20:02:30 <elliott> Gregor: Neat
20:02:48 <elliott> ais523: but I believe this means I can't actually do the type trick I was planning :)
20:02:58 <ais523> indeed, I tried to do that trick too
20:03:05 <ais523> but it doesn't work
20:03:07 <elliott> ais523: what type does exit take? 1 or 2?
20:03:19 <ais523> exit's of type 1
20:03:28 <elliott> ais523: no it isn't
20:03:31 <elliott> ais523: it isn't a program
20:03:32 <elliott> so it has no type
20:03:39 <elliott> ais523: in (Exit p), what type must p have?
20:03:49 <ais523> elliott: it takes one argument of type 2; that's the definition of being type 1
20:04:00 <elliott> ais523: it doesn't take an argument at all, because it's not a program!
20:04:03 <elliott> it's a function from program to program
20:04:08 <ais523> no it isn't
20:04:10 <elliott> Call1 (Exit, ...) # not valid
20:04:17 <elliott> ais523: it is, I'm looking at your ADT /right now/
20:04:20 -!- derrik has quit (Quit: /clear).
20:04:20 <ais523> elliott: Call1 (Call1, ...) # not valid
20:04:28 <elliott> yes, which is why Call1 doesn't have a type
20:04:30 <elliott> because it's not a program
20:04:47 <ais523> and yet Call1 (0, Var2 0) is a program
20:04:54 <elliott> ...yes?
20:05:00 <elliott> (Exit p) is a program, obviously
20:05:03 <elliott> Exit isn't
20:05:05 <ais523> ah, right
20:05:15 <elliott> therefore Exit doesn't have a type, because a type is something programs have
20:05:23 <ais523> in that case, Exit takes a program of type 2 and returns a program of type 1
20:05:40 <elliott> right; and I assume Error is a program of type 1 or 2, i.e. polymorphic?
20:05:52 <ais523> nah, Error is me getting rid of code duplication
20:05:58 <ais523> it's of type 1, always
20:06:07 <elliott> OK
20:06:14 <elliott> data T1
20:06:15 <elliott> data T2
20:06:15 <elliott> data Exp t where
20:06:15 <elliott> Var :: Var t -> Exp t
20:06:15 <elliott> Call1 :: Var T1 -> Exp T2 -> Exp ???
20:06:15 <elliott> Call2 :: Var T2 -> Exp T1 -> Exp T2 -> Exp ???
20:06:17 <elliott> Exit :: Exp T2 -> Exp T1
20:06:17 <ais523> because I use the same codepaths for type 1 stuff (that don't have a type 1 arg) and type 2 stuff (which does have a type 1 arg)
20:06:19 <elliott> Error :: Exp T1
20:06:21 <elliott> this is why the trick fails :)
20:06:23 <elliott> you can't fill in ???
20:06:35 <ais523> and just stick in Error as the type 1 arg
20:06:41 <elliott> if I understood the language, I could probably do a better trick to reify the types, but I don't understand it well enough to do that now
20:06:43 <elliott> ais523: ewwwww
20:06:47 <elliott> ais523: I'm not going to have Error
20:06:53 <ais523> I know >:)
20:06:57 <ais523> elliott: I didn't think you would
20:07:12 <elliott> ais523: btw, why is it (Exit of program) instead of just Exit, used like Call1 (Exit, p)?
20:07:49 <ais523> elliott: the given program is executed to calculate the return value
20:08:00 <elliott> ais523: and so it would be with Call1 (Exit, p), no?
20:08:09 <elliott> or is this me not understanding the semantics again :)
20:08:20 <elliott> the problem with the understanding-by-implementation approach is that it involves implementation
20:08:29 <ais523> it's a side-effect of being hypereager
20:08:43 <ais523> suppose Exit ends up being substituted into the first position of a Call
20:08:51 <ais523> it can't be there, so needs to be evaluated immediately, but without exiting the program
20:09:06 <ais523> so the argument to Exit's basically there to defer the evaluation
20:09:49 <elliott> heh
20:09:54 <ais523> I think the language probably needs a strictifier, incidentally, it'd avoid this sort of problem
20:10:09 <ais523> and make writing safe infinite loops rather easier
20:10:13 <elliott> ais523: Is Error something inherent to the language or just a way to get nicer reports than non-halting?
20:10:15 <ais523> but you wouldn't have to expand the language syntax at all
20:10:33 <ais523> elliott: Error isn't inherent to the language, it's simply there because I'm lazy
20:10:37 <elliott> erm
20:10:39 <elliott> ais523: Exit, I mean
20:10:40 <ais523> you can write an impl without it, and probably produce nicer error messages
20:10:40 <elliott> sorry!
20:11:00 <elliott> http://i.imgur.com/1uOhf.png ;; this is the first time I have ever used three windows in Emacs
20:11:30 <ais523> oh, basically, the input is a type 2 program and its type 2 arg; Exit is the type 1 arg it's given when it starts executing
20:11:48 <ais523> so it wouldn't be needed if you didn't care about your programs being able to terminate
20:12:02 <ais523> you could just use type 1 programs rather than type 2 programs as the initial input
20:14:30 <Gregor> elliott: OK, new reason for not testing on Alpha: I can't get a bloody cross-compiler at all >_<
20:15:25 <elliott> ais523: I need a wider screen to do this three-pane coding :(
20:15:41 <ais523> elliott: I typically split one of the halves horiziontally when doing three-pane
20:15:47 * elliott just switched to that
20:15:55 <ais523> well, with a horizontal divider
20:17:04 <elliott> ais523: Partial list of words I don't know the meanings of in the slightest: ig, incg, decg, substat
20:17:29 <ais523> btw, it's entirely possible to write a program that doesn't type, such as (0 0 (0 0 0)); atm, I detect type errors at runtime rather than statically
20:17:53 <ais523> anyway, incg and decg are basically used to adjust open terms
20:17:55 <ais523> inside substat
20:18:24 <ais523> and substat itself does substitutions in the typical lambda-calculusy way
20:18:47 <elliott> ais523: huh? you don't need substitutions with de bruijn
20:19:10 <ais523> elliott: how are you going to implement an application of a lambda otherwise?
20:19:32 <elliott> ais523: you use a linked list; cons onto it when you do a call, and just index it when a variable is looked up
20:19:40 <elliott> var 0 = car, var 1 = cadr, etc.
20:19:57 <ais523> elliott: but what if that variable hasn't been evaluated yet?
20:19:57 <elliott> and, ofc, you don't need alpha renaming
20:20:01 <ais523> hypereager, remember?
20:20:08 <elliott> ais523: what about it?
20:20:22 -!- Phantom__Hoover has joined.
20:20:31 <Phantom__Hoover> <elliott> http://i.imgur.com/1uOhf.png ;; this is the first time I have ever used three windows in Emacs ← You've never used Proof General?
20:20:31 <lambdabot> Phantom__Hoover: You have 1 new message. '/msg lambdabot @messages' to read it.
20:20:43 <elliott> Phantom__Hoover: That doesn't couuunt.
20:20:56 <Phantom__Hoover> XD
20:21:03 <ais523> elliott: example: I just gave (0 (0 (2 0 (2 1 (1 0 2))))) and (0 0) as input to the interpreter (s and i)
20:21:12 <ais523> and here's the debug output:
20:21:15 <ais523> (0c (0c (2v 0v (2v 1v (1v 0v 2c))))) [(0c 0v), (exit 0v)]
20:21:17 <ais523> (exit 0v) [(0c (1v 0v (1v 0v 1c))), error]
20:21:18 <ais523> (0c (1v 0v (1v 0v 1c)))
20:21:39 -!- Phantom__Hoover has changed nick to Phantom___Hoover.
20:21:41 <elliott> you know that's not going to help me; ais523: if you mean that you have to evaluate expressions before consing them, so what?
20:21:43 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
20:21:47 <elliott> you can do that easily
20:21:49 <Phantom___Hoover> Hmm.
20:21:53 <ais523> elliott: no, you have to cons them before knowing what they are
20:21:59 <Phantom___Hoover> elliott, shoddy.
20:22:02 -!- Phantom___Hoover has changed nick to Phantom_Hoover.
20:22:06 <elliott> ais523: oh, right; that's easy
20:22:08 <shachaf> Phantom_Hoover!
20:22:15 <elliott> ais523: you just use a linked list of (Maybe Exp) instead
20:22:17 <Phantom_Hoover> shachaf!
20:22:20 <elliott> Nothing means you don't know what it is yet
20:22:28 <shachaf> Phantom_Hoover: Don't you owe me a message or two?
20:22:30 <ais523> elliott: but how can you tell which Nothing is which afterwards?
20:22:43 <elliott> ais523: what?
20:22:46 <Phantom_Hoover> @tell shachaf friendship message
20:22:47 <lambdabot> Consider it noted.
20:22:59 <ais523> here: in the above example, I start with (0 (0 (2 0 (2 1 (1 0 2))))), then substitute in (0 0) and exit
20:23:09 <ais523> and get exit (0 (1 0 (1 0 1)))
20:23:45 <ais523> basically, we're substituting for the first 2 in (0 (2 0 (2 1 (1 0 2))))
20:23:47 <elliott> you're just going to keep quoting programs at me you know I can't yet read, right? anyway, the whole point is, if you get Nothing, abort reduction of that variable
20:23:54 <elliott> but failing that, you can have (Either Int Exp) instead
20:24:00 <elliott> if you want to keep track of them
20:24:04 -!- tiffany has joined.
20:25:46 <ais523> elliott: OK; so suppose I want to evaluate the following open term: (0 0) applied to 0 and (2 1 (1 0 2)); that's going to give me ((2 1 (1 0 2)) 0), but I don't know what the 2 at the start refers to
20:25:53 <ais523> because it refers beyond the start of the expression
20:26:00 <ais523> hmm, let me translate into lambda calculus
20:27:08 -!- oerjan has joined.
20:27:30 <ais523> wait, I'm confused
20:27:33 <elliott> hi oerjan
20:27:40 <oerjan> hello
20:28:03 <ais523> I'm pretty certain your suggestion is incorrect, but need a bunch of calculation to work out why
20:28:27 <elliott> ais523: lol
20:28:40 <elliott> oerjan: i implemented your cursor stuff and PSeq, just without any operations :P
20:28:54 <elliott> oerjan: also, turns out what i thought the gadt record syntax was is deprecated, you were right with Foo :: { ..., ... } -> R
20:29:07 <ais523> elliott: I think it's because it gets the evaluation order wrong
20:29:31 <shachaf> elliott: No, it's Foo :: { a :: Int } -> { b :: Char} -> R, isn't it?
20:29:34 <elliott> ais523: I refuse to believe you have an evaluation scheme which cannot be implemented with an environment and absolutely requires substitution; that's patently ridiculous
20:29:42 <elliott> ais523: even if my specific solution doesn't work
20:29:59 <oerjan> elliott: aha. i noticed wrt PSeq you said something about unsafeCoerce :P
20:30:08 <ais523> elliott: there probably is a way to do it with an environment, just not the way you suggested
20:30:08 <elliott> shachaf: Nope.
20:30:11 <oerjan> i guess that may be the simplest way to implement it
20:30:23 <elliott> oerjan: yes, I didn't feel like implementing my own finger trees :P
20:30:34 <ais523> but I fear it'd get exponentially complex to maintain the environment
20:30:51 -!- Zuu has joined.
20:31:17 <elliott> ais523: I doubt it
20:31:38 <shachaf> elliott: Ugh.
20:31:43 <elliott> ais523: I don't see why Unknown doesn't work; if you get Unknown back, then behave as you would with an unsubstituted variable reference in a substituting implementation
20:31:46 <shachaf> You're right.
20:31:57 <ais523> elliott: let's see… suppose I have \x.(… some expression containing a call of x …), and apply a value to it
20:32:10 * shachaf thinks GADT syntax and regular syntax could be unified into something better pretty easily.
20:32:40 <ais523> so, I have one append-only stack (because no returns) that contains the values of open terms in the current expression
20:32:59 <ais523> and then, I have to traverse the inside of the brackets to find all uses of x in call position, and evaluate them immediately
20:33:01 <elliott> oerjan: zipper.hs: http://sprunge.us/BDYL
20:33:05 <elliott> oerjan: PSeq.hs: http://sprunge.us/IBPQ
20:33:20 <elliott> ais523: mmhm
20:33:31 <ais523> so what stack do I use to evaluate /those/?
20:33:38 <ais523> and what do I put on it?
20:34:25 <elliott> ais523: say the environment for ((\x. ... (x e) ...) xv) is [a,b,c]; the environment for evaluating (x e) is [xv,a,b,c]
20:34:57 <elliott> say x = \q.u
20:34:59 <ais523> hmm… that breaks the links between numbers and positions in the list
20:35:11 <elliott> then the environment for evaluating u is [e,a,b,c]
20:35:13 <elliott> because scoping
20:35:15 <elliott> ais523: no it doesn't
20:35:26 <elliott> ais523: [xv,a,b,c]!!0 = xv
20:35:29 <elliott> [xv,a,b,c]!!1 = a
20:35:33 <ais523> elliott: what if I have ((\x. … ( … (x e )) …) xv)
20:35:36 <elliott> de bruijn is retained
20:35:49 <elliott> ais523: calls don't introduce new bindings, so that's irrelevant
20:35:56 <ais523> I'm going to need to use [xv,?,a,b,c] as the list
20:36:09 <elliott> what?
20:36:15 <ais523> wait, no, [?,xv,a,b,c]
20:36:25 <ais523> elliott: think of it in number terms; x won't be 0 inside (x e)
20:36:28 <ais523> it'll be some larger number, like 2
20:36:45 <elliott> ais523: no it won't, unless by "..." you meant "... that includes a lambda"
20:36:50 <ais523> elliott: err, right
20:36:57 <ais523> all open parens imply a lambda in NEF
20:37:04 <ais523> so counting parens and counting lambdas comes to the same thing
20:37:18 <elliott> ais523: so what you're discovering is, parsing an expression containing variables into de bruijn requires a map from variable name to integer
20:37:27 <elliott> and each integer increases for each new lambda
20:37:31 <elliott> shocking
20:37:44 <elliott> however, unrelated to the semantics of a language coded directly in de bruijn
20:38:01 <ais523> elliott: we're talking about the implementation
20:38:26 <elliott> yes, and you have successfully confused the issue by using named variables which has somehow turned into a point involving conversion to de bruijn
20:38:36 <elliott> which is irrelevant since named variables feature nowhere except in your attempted explanation afaict
20:39:02 <ais523> elliott: I was going on /your/ example
20:39:08 <ais523> because you refuse to read examples involving numbers
20:40:25 <elliott> ais523: if it were de bruijn lambda calculus i would understand perfectly
20:40:39 <elliott> but I do "refuse" (am unable to) understand examples in a language I'm in the process of trying to understand, yes
20:40:48 <ais523> it sort-of is, just with a weird evaluation order
20:40:54 <ais523> what syntax do you want for de bruijn lambda calculus?
20:41:48 <elliott> exp := int | '(\' exp ')' | '(' exp exp ')', with omitted parens for repeated left-associative application, and whitespace to separate integers?
20:42:05 <elliott> and parens on outermost lambdas omittable, etc.
20:44:35 <ais523> ah, OK
20:45:34 <ais523> NEF's syntax is basically that, except that it uses (…) rather than (\…), and that a lambda can take two arguments instead of one; both of the arguments has the same number, and it works out which is being referred to by the type
20:45:57 <elliott> well, OK; I certainly have a better understanding of the lambda-calculus though
20:48:08 <Gregor> *First time looking at VAX* I like how VAX is clearly the primary influence for x86 :P
20:48:46 <elliott> Gregor: http://esolangs.org/wiki/User:Ian#DEC_VAX
20:48:58 <elliott> Gregor: ("Other Neat CPUs" section is great also)
20:49:45 <elliott> Gregor: CALLG is really cool, hardware varargs :P
20:49:49 <elliott> POLYx is also hilarious
20:50:05 <elliott> "CASEx has a format like this: selector.rx, base.rx, limit.rx, displ[0].bw, ..., displ[limit].bw The instruction has "limit+3" operands. Not only can the VAX not tell how long the instruction is until it's completely decoded, it can't even tell how many operands it has! The whole thing can be 4GB long. Technically it can be 8GB long, but the VAX only has 4GB of addressing space."
20:50:18 <Gregor> Incidentally, my JIT currently does not (seem to?) work on VAX, and I think I know why, but not how to fix it ...
20:50:19 <elliott> ais523: well, go on
20:50:33 <ais523> err, I'm in the middle of something else
20:50:39 <ais523> I get distracted easily
20:50:41 <elliott> heh
20:50:43 <Gregor> Also, NetBSD VAX = yesssssssssssssss
20:50:45 <elliott> Gregor: Try it on this: http://esolangs.org/wiki/Talk:Timeline_of_esoteric_programming_languages#AS.2F400
20:51:42 <elliott> oerjan: did you look :P
20:51:52 <oerjan> elliott: in your foldr, i think the (forall a. result a a) can simply be result dest dest
20:52:00 <Gregor> elliott: Need compiler and simulator (also, CISC is usually the easiest, I think the issue with VAX is that it has markers at the beginning of functions which are not valid instructions but need to be there (?????))
20:52:22 <elliott> oerjan: hmm, so it can. that seems really ugly: why can't it be result src src, too?
20:52:44 <pikhq_> Gregor: Not *really*; x86 was more influenced by earlier Intel designs than anything else. That said, CISC had a lot of crazy stuff.
20:52:50 <pikhq_> Also, yay 32-bit PDP-11!
20:53:04 <Gregor> elliott: Yup, my generated code totally has halts in it :P
20:53:30 <ais523> Gregor: hmm, is VAX the architecture that didn't have a stack, but rather stored return addresses just before the start of a function?
20:53:57 <Gregor> ais523: ... I can't imagine so, that wouldn't work with C very well. Recursion and what have you.
20:54:17 <ais523> it didn't, IIRC
20:54:40 <pikhq_> I doubt it.
20:54:44 <oerjan> elliott: result src src would be for foldl, obviously... it's what replaces the right and left end, respectively.
20:54:56 <elliott> oerjan: oh, right
20:55:09 <olsner> hmm, but isn't AS/400 or i that thing that has a machine-independent binary format and is currently implemented using POWER7?
20:55:11 <elliott> oerjan: what's weird about seqs is that they have, I think, four folds
20:55:20 <elliott> oerjan: foldr, foldl, foldrFromRight, foldlFromRight
20:55:32 <oerjan> heh
20:55:33 <pikhq_> Seeing as the PDP-11 used a stack, and the VAX started as a 32-bit PDP-11.
20:55:48 <elliott> oerjan: although, I suspect that foldr == foldlFromRight and foldl == foldrFromRight in results, just not in semantics
20:55:52 <elliott> err
20:55:55 <elliott> oerjan: as in, evaluation semantics
20:56:15 <oerjan> elliott: presumably it may matter in thunk buildup
20:56:22 <elliott> oerjan: right, that's what I meant
20:56:36 <elliott> oerjan: incidentally, i note that one can have a PSeq of PSeqs...
20:56:43 <elliott> i.e. (PSeq (PSeq path) src dest)
20:56:48 <elliott> oerjan: which got me wondering what Mu PSeq is >:)
20:57:05 <elliott> oerjan: unfortunately I think it's just data Foo = Foo | Bar Foo Foo
20:57:21 <elliott> and there's no value with src =/= dest
20:58:16 <oerjan> elliott: in fact you would probably want foldl to be fromRight by default, since the other options just add thunks needlessly; the ' versions though would go the other way for both foldl and foldr.
20:58:25 <elliott> oerjan: right
20:59:32 <olsner> also, who's this "Ian"? I'd like him to explain why CASEx needs to be completely decoded to know how many operands it has
20:59:50 <oerjan> elliott: PSeq is sort of a * -> * -> * type transformer
20:59:54 <elliott> olsner: esowiki guy, ping him on his talk page or use the wiki email thing?
21:00:00 <elliott> oerjan: indeed
21:00:14 <elliott> oerjan: incidentally, you can't implement Show (PSeq path src dest) because you need (forall a b. Show (path a b)) :-(
21:00:15 <olsner> afaict, limit is the third operand and should say exactly how long the rest of it is
21:00:19 <oerjan> elliott: oh and one other thing i thought of, you could make a Category instance for PSeq
21:00:23 <elliott> oerjan: ooh
21:00:24 <olsner> elliott: meh, can't be bothered logging in
21:00:27 <elliott> oerjan: shiny
21:00:29 <olsner> I probably even have an account
21:00:46 <oerjan> elliott: it's sort of a free category on the path type
21:01:06 <elliott> oerjan: i wonder if it's an arrow... arr seems tricky, maybe it's an arrow if the path is
21:02:33 <elliott> oerjan: it's a super pretty structure
21:03:49 <oerjan> elliott: i think your Mu PSeq is more than that; it would allow constructing empty PSeq's at all nesting levels wouldn't it, so it would work similarly to building up set theory from empty lists. oh hm you could never get a PSeq a b for a /~ b, i think, so it may be equivalent to Mu Seq.
21:04:11 <elliott> oerjan: that's what i said
21:04:15 <elliott> data Foo = EmptyList | Cons Foo Foo
21:04:35 <elliott> [[],[],[]] = Cons EmptyList (Cons EmptyList (Cons EmptyList EmptyList))
21:04:36 <elliott> etc.
21:04:42 <oerjan> elliott: well if you consider cons lists equivalent to Seq's...
21:04:47 <elliott> well ok
21:04:55 <elliott> @src foldl'
21:04:56 <lambdabot> foldl' f a [] = a
21:04:56 <lambdabot> foldl' f a (x:xs) = let a' = f a x in a' `seq` foldl' f a' xs
21:05:00 <elliott> darn, they just use an ugly let too
21:05:42 <elliott> oerjan: yikes, I'm not sure foldr' is possible
21:05:48 <elliott> oerjan: because of the fiddly parametrisation
21:06:04 <oerjan> elliott: you might implement Show if you made a Show2 class for path
21:06:08 <elliott> oerjan: indeed
21:06:17 <elliott> (***) :: PSeq path a b -> PSeq path b' c' -> PSeq path (b, b') (c, c')
21:06:20 <elliott> oerjan: wow that's pretty
21:06:23 <elliott> it's like simulwalking!!
21:06:28 <elliott> ...not sure it's possible though
21:06:31 <elliott> because what if the lengths differ
21:09:19 <oerjan> why would foldr' (and equivalently foldl') not work?
21:09:23 <elliott> oerjan: because
21:09:27 <elliott> Expected type: result a a
21:09:27 <elliott> Actual type: result mid dest
21:09:27 <elliott> In the second argument of `foldr'', namely `z''
21:09:27 <elliott> In the second argument of `seq', namely `foldr' f z' ps'
21:09:33 <elliott> where z' = f pn z from the right
21:10:11 <oerjan> ...oh i see
21:10:18 <oerjan> you can relax the type
21:10:29 <elliott> how?
21:10:35 <oerjan> foldr :: (forall a b c. path a b -> result b c -> result a c) -> (forall a. result a a) -> PSeq path src dest -> result src dest
21:10:43 <oerjan> (just pasting to get something to edit)
21:10:50 <elliott> I already releaxed foldr to result dest dest
21:10:53 <elliott> and this doesn't work with that
21:10:56 <elliott> or the quantified version
21:11:12 <oerjan> foldr :: (forall a b c. path a b -> result b c -> result a c) -> result dest end -> PSeq path src dest -> result src end
21:11:27 <oerjan> _that_ might work, and even with foldr'
21:12:09 <elliott> same error:
21:12:11 <elliott> Expected type: PSeq path src mid
21:12:11 <elliott> Actual type: PSeq path src dest
21:12:11 <elliott> In the third argument of `foldr'', namely `ps'
21:12:11 <elliott> In the second argument of `seq', namely `foldr' f z' ps'
21:12:15 <elliott> oh hm
21:12:22 <elliott> that's not the same error but it's still a mismatch
21:12:23 <oerjan> ?
21:12:35 <elliott> foldr'
21:12:35 <elliott> :: (forall a b c. path a b -> result b c -> result a c)
21:12:35 <elliott> -> result dest end
21:12:35 <elliott> -> PSeq path src dest
21:12:35 <elliott> -> result src end
21:12:36 <elliott> foldr' f z ps =
21:12:38 <elliott> case viewr ps of
21:12:40 <elliott> PEmptyR -> z
21:12:41 <oerjan> oh hm
21:12:42 <elliott> ps' :> pn ->
21:12:44 <elliott> let z' = f pn z
21:12:46 <elliott> in z' `seq` foldr' f z' ps
21:12:48 <elliott> /home/elliott/Code/shiro/PSeq.hs:98:31:
21:12:50 <elliott> Couldn't match type `dest' with `mid'
21:12:52 <elliott> `dest' is a rigid type variable bound by
21:12:54 <elliott> the type signature for
21:12:56 <elliott> foldr' :: (forall a b c. path a b -> result b c -> result a c)
21:12:58 <elliott> -> result dest end
21:12:59 <oerjan> elliott: foldr :: (forall a b c. path a b -> result b -> result a) -> result dest end -> PSeq path src dest -> result src
21:13:00 <elliott> -> PSeq path src dest
21:13:02 <elliott> -> result src end
21:13:04 <elliott> at /home/elliott/Code/shiro/PSeq.hs:93:1
21:13:06 <elliott> `mid' is a rigid type variable bound by
21:13:08 <elliott> a pattern with constructor
21:13:10 <elliott> :> :: forall (path :: * -> * -> *) src dest mid.
21:13:12 <elliott> PSeq path src mid -> path mid dest -> PViewR path src dest,
21:13:14 <elliott> in a case alternative
21:13:16 <elliott> at /home/elliott/Code/shiro/PSeq.hs:96:5
21:13:18 <elliott> Expected type: PSeq path src mid
21:13:20 <elliott> Actual type: PSeq path src dest
21:13:22 <elliott> In the third argument of `foldr'', namely `ps'
21:13:24 <elliott> In the second argument of `seq', namely `foldr' f z' ps'
21:13:26 <elliott> Failed, modules loaded: none.
21:13:28 <elliott> oerjan: wat
21:13:30 <elliott> oerjan: "-> result dest end ->"
21:13:40 <oerjan> er oops
21:13:50 <oerjan> foldr :: (forall a b c. path a b -> result b -> result a) -> result dest -> PSeq path src dest -> result src
21:14:04 <elliott> foldr', presumably
21:14:17 <oerjan> it is slightly awkward if you actually _want_ a type with dest in it, i guess...
21:14:19 <elliott> Expected type: PSeq path src mid
21:14:19 <elliott> Actual type: PSeq path src dest
21:14:19 <elliott> In the third argument of `foldr'', namely `ps'
21:14:19 <elliott> In the second argument of `seq', namely `foldr' f z' ps'
21:14:26 <oerjan> (because of wrong type argument order)
21:14:43 <elliott> oerjan: otoh it does work as a type for foldr
21:14:43 <oerjan> foldl wouldn't have _that_ problem
21:14:47 <elliott> but not for foldr'
21:14:57 <elliott> oerjan: but then foldr (<|) empty doesn't type
21:14:58 <elliott> so lol
21:15:15 <oerjan> indeed, wrong type argument order
21:15:27 <oerjan> the changing argument doesn't get last
21:16:33 <elliott> oerjan: foldl' doesn't type either
21:16:40 <elliott> also, the arguments always change with (<|)
21:16:42 <elliott> apart from path
21:18:13 <oerjan> elliott: oh you have a bug
21:18:25 <elliott> oerjan: ok tell me but beforehand
21:18:28 <elliott> look at this
21:18:29 <elliott> foldr (>>>) id
21:18:30 <elliott> :: Category path => PSeq path src dest -> path src dest
21:18:31 <oerjan> in z' `seq` foldr' f z' ps should be in z' `seq` foldr' f z' ps'
21:18:32 <elliott> that is beautiful :')
21:18:46 <elliott> oerjan: oh
21:18:49 <elliott> will that fix things? :P
21:18:56 <oerjan> let's hope :P
21:19:21 <elliott> nope
21:19:30 <oerjan> D:
21:19:48 <elliott> oerjan: oh wait
21:19:55 <elliott> oerjan: i think what needs changing is the type of f
21:19:57 <elliott> oerjan: to go /backwards/
21:20:42 <elliott> oerjan: i'm not sure what that looks like, though :P
21:22:11 <elliott> oerjan: argh, here's another bug for you
21:22:13 <elliott> singleton :: path a a -> PSeq path a a
21:22:19 <elliott> oerjan: how stupid can I be??
21:24:21 <elliott> oerjan: omg omg omg
21:24:26 <elliott> oerjan:
21:24:27 <elliott> instance (Arrow (~>)) => Arrow (PSeq (~>)) where
21:24:27 <elliott> arr = singleton . arr
21:24:27 <elliott> first ps =
21:24:27 <elliott> case viewl ps of
21:24:27 <elliott> PEmptyL -> empty
21:24:29 <elliott> pn :< ps' -> first pn <| first ps'
21:25:24 <elliott> oerjan is not nearly excited enough.
21:26:23 <oerjan> maybe not.
21:26:43 <oerjan> does that foldr' compile (although with warning) if you remove the empty branch?
21:27:32 <elliott> oerjan: i'll try. but dude, PSeq is an arrow transformer!!!
21:28:01 -!- Ngevd has joined.
21:28:04 <elliott> oerjan: no
21:28:10 <elliott> Expected type: PSeq path src dest
21:28:10 <elliott> Actual type: PSeq path src mid
21:28:10 <elliott> In the third argument of `foldr'', namely `ps''
21:28:10 <elliott> In the expression: foldr' f (f pn z) ps'
21:28:14 <elliott> (yeah yeah I know it's not strict yet :P)
21:28:40 <elliott> oerjan: you know, I could just unsafeCoerce this through
21:28:55 <elliott> it's obviously a valid implementation
21:30:01 <oerjan> >_>
21:31:11 <elliott> oerjan: you realise viewl/viewr unsafeCoerce already :P
21:31:34 <elliott> oerjan: hm i note that there are two possible Categories for PSeq
21:31:38 <oerjan> oh hm is it complaining about the foldr' being used with polymorphic recursion, _despite_ having a type signature?
21:31:44 <elliott> instance Category (PSeq path) where id = empty; (.) = flip (><)
21:32:00 <elliott> instance (Category path) => Category (PSeq path) where id = singleton id; (.) = fold blah blah
21:32:09 <elliott> oerjan: no, it's complaining because _ps' does not match the zero passed_
21:32:53 <oerjan> hm...
21:33:41 <elliott> app :: (ArrowApply (~>)) => PSeq (~>) (PSeq (~>) b c, b) c
21:33:43 <elliott> THIS WILL BE FUN
21:35:41 <oerjan> elliott: what is your current code for foldr' ?
21:35:57 <elliott> oerjan: i rewrite it every time you come up with another idea. do you just want a file with foldr' in it? :P
21:36:13 -!- boily has quit (Ping timeout: 252 seconds).
21:36:29 <oerjan> i just want to see if you broke it in some way i haven't seen while fixing my bug reports :P
21:36:30 -!- copumpkin has changed nick to luke-sr.
21:36:42 <elliott> charming :P
21:36:46 <elliott> one second
21:36:56 <elliott> hmm I have to write basically (PSeq (~>) b c, b) ~> c
21:37:17 -!- luke-sr has changed nick to copumpkin.
21:37:39 <elliott> oerjan: http://sprunge.us/cjcR
21:37:39 -!- Patashu has joined.
21:38:03 <elliott> ok, I have (b ~> c, b) ~> c
21:38:10 <elliott> and I need to turn that into (PSeq (~>) b c, b) ~> c
21:38:40 <elliott> so... app . first f
21:38:56 <oerjan> elliott: you removed the end type again, i believe that's essential
21:39:14 <elliott> oerjan: oh, right.
21:39:20 <elliott> oerjan: i told you it doesn't type with that, either, but ok i'll try
21:39:35 <oerjan> yes, but with that _and_ the ps fixed to ps' ? :P
21:39:55 <elliott> oerjan: you'll never believe it
21:40:00 <oerjan> hm?
21:40:07 <elliott> oerjan: it works :P
21:40:11 * elliott generalises foldr's type to that too
21:40:11 <oerjan> yay :P
21:41:26 <oerjan> for foldl and foldl' you can give result just one type argument, i think, because the fixed src is in the right place to be combined into result
21:42:29 <elliott> oerjan: huh, so you can.
21:42:35 <elliott> oerjan: that upsets me though :( it's so inconsistent
21:42:52 -!- DCliche has joined.
21:43:27 <elliott> oerjan: :'(
21:43:37 <elliott> oerjan: it also feels wrong that the more natural fold is the one which needs more gunk
21:43:41 <oerjan> you can do that with foldr[']? too, but then as you say foldr (>>>) id won't type
21:44:08 <elliott> oerjan: not foldr (<|) empty either
21:44:49 <elliott> PSeq (~>) (b, d) (c, d) -> PSeq (~>) b c
21:44:50 <elliott> aaaaaaaa
21:44:56 <oerjan> because the type variable you want to combine is in the last place
21:45:18 <oerjan> wat
21:45:25 <oerjan> oh the loop
21:45:26 <elliott> oerjan: loop :: a (b,d) (c,d) -> a b c
21:45:30 <elliott> instance ArrowLoop (->) where
21:45:30 <elliott> loop f b = let (c,d) = f (b,d) in c
21:45:41 <elliott> god knows how to implement it for paths :P
21:45:48 <elliott> i suppose i want to tie each node to itself?
21:45:54 <elliott> or do i want to tie each node to the next node, and the last to the first...
21:46:02 -!- Darth_Cliche has quit (Ping timeout: 244 seconds).
21:46:18 <oerjan> you'd want to tie the final node to the first one?
21:46:32 <elliott> oerjan: that's what I said
21:46:38 <elliott> either that, or tie each node to itself, which seems useless
21:47:30 <monqy> does arrowloop have any laws
21:47:36 <elliott> monqy: "ow"
21:47:42 <elliott> (probably yes but they're in a paper)
21:47:46 <oerjan> it's entirely lawless and evil
21:47:49 <Ngevd> Learnt about Matrices in maths today
21:48:03 <Ngevd> Finally figured out what they're up to
21:48:06 <monqy> exciting?? I dislike matrices. yukce
21:48:19 <Ngevd> They were kinda dissapointing
21:48:24 <elliott> oerjan: oh well, I'll stick to the easy ones (ArrowZero, ArrowChoice)
21:48:26 <monqy> what did you expect
21:48:32 <oerjan> matrices are cool. just use a more interesting underlying ring :P
21:48:39 <Ngevd> monqy, I dunno, something interesting
21:48:43 <Gregor> elliott: Works on Alpha with no changes.
21:48:48 <Phantom_Hoover> Ngevd, you did graphs before matrices????
21:48:49 <Ngevd> oerjan, I don't think I need that at AS level
21:48:49 <elliott> oerjan: hmm...
21:48:53 <Ngevd> Phantom_Hoover, yup
21:48:56 <elliott> oerjan: I think you might want singleton id == empty
21:48:57 <elliott> oerjan: for PSeqs
21:49:01 <monqy> oerjan: there is nothing you can do to make matrices cool sory :(
21:49:07 <elliott> oerjan: when the path is a category
21:49:08 <Gregor> elliott: Have I mentioned that this JIT is magic and amazing :P
21:49:13 <elliott> Gregor: Yes.
21:49:29 <oerjan> elliott: if you do that, you need to elude _all_ singleton id's
21:49:35 <elliott> oerjan: yeah :P
21:49:36 <elliott> kinda tricky
21:49:44 <elliott> oerjan: ok, so this is a decent PSeq
21:49:51 <elliott> oerjan: now it need to be applied >:)
21:49:58 <elliott> oerjan: oh yeah, about MetaContext
21:50:09 <elliott> 04:25:05: <oerjan> data MetaContext = MetaContext { nwNeighbor :: MetaCursor (To NW), ..., up :: MetaCursor dir, signPost :: SignPost } -- it occurs to me that some field name disambiguation will be needed
21:50:12 <elliott> oerjan: are all neighbours present here?
21:50:17 <elliott> or is one elided?
21:51:05 <oerjan> all, i should think...
21:51:10 <oerjan> oh hm
21:51:21 <oerjan> there needs to be a Leaf version of that too
21:51:21 <elliott> oerjan: well the next question is "wtf is dir"
21:51:51 <oerjan> elliott: the usual, the direction this node is in relation to its parent
21:51:54 <ais523> elliott: hmm, I think you could make a stack-based solution work, but it's dubious that it's better than substitution in this case
21:52:03 <elliott> oerjan: so quantified?
21:52:06 <oerjan> elliott: oh should probably be From dir
21:52:15 <ais523> as far as I can tell, substitution is more space-efficient and equally time-efficient
21:52:26 <elliott> oerjan: what does the leaf version look like?
21:52:30 <Phantom_Hoover> Ngevd, wait, have you learnt matrix multiplication?
21:52:36 <elliott> ais523: well, OK
21:52:41 <oerjan> elliott: it has no neigbors, i'd think
21:52:48 <oerjan> only the up and the signPost
21:52:50 <elliott> oerjan: so just (MetaCursor dir, SignPost)?
21:52:50 <elliott> ok
21:53:02 <elliott> oerjan: what's the non-leaf case? aka name the constructor :P
21:53:09 <ais523> the problem is that the stack would only ever be pushed, and you'd have to GC the bottom of the stack when it went out of scope, which is nontrivial to determine
21:53:19 <Ngevd> Phantom_Hoover, just today
21:53:36 <Phantom_Hoover> Ngevd, matrix multiplication is the worst.
21:53:41 <monqy> it's awful
21:53:45 <Ngevd> It's messed up
21:53:47 <oerjan> InternalContext ?
21:53:52 <monqy> not really messed up
21:53:54 <monqy> just awful
21:54:01 <Phantom_Hoover> I need to stare into space for a minute to remember which way round everything is.
21:54:05 <Ngevd> I keep losing track of it
21:54:05 <monqy> yeah
21:54:19 <elliott> oerjan: um i was hoping for something short to compliment MCLeaf
21:54:31 <Phantom_Hoover> I think I've been taught it three different times by now.
21:54:47 <Ngevd> Sounds like you have a very good maths teacher
21:55:01 <Ngevd> We've been taught simultaneous equations a few dozen times
21:55:56 <Phantom_Hoover> Have you done them with MATRICES?
21:56:21 <Ngevd> Not yet
21:56:32 <Ngevd> We've been hinted at that we will shortly
21:56:35 <oerjan> > let mult m1 m2 = [[sum$zipWith(*)r1 c2 | c2 <- transpose m2]| r1 <- m1] in mult [[1,0],[0,2]] [[1,2,3],[4,5,6]]
21:56:36 <lambdabot> [[1,2,3],[8,10,12]]
21:56:47 <elliott> oerjan: MCFrom? MCTo? work with me here :P
21:56:57 <elliott> argh, the MC prefix clashes with MetaCursor
21:56:58 <oerjan> oh hm
21:57:04 <oerjan> MCInner
21:57:07 -!- pikhq has joined.
21:57:14 -!- pikhq_ has quit (Ping timeout: 258 seconds).
21:57:33 <Phantom_Hoover> Ngevd, and then, through some process that was never adequately explained to me, you use them for cross products.
21:57:37 <elliott> data MetaNode exit where
21:57:37 <elliott> MNFrom :: Neighbours1 MetaCursor dir
21:57:37 <elliott> -> MetaCursor (From dir)
21:57:37 <elliott> -> SignPost
21:57:37 <elliott> -> MetaNode (From dir)
21:57:38 <elliott> MNTo :: Neighbours MetaCursor -> SignPost -> MetaNode (To dir)
21:57:40 <elliott> MNLeaf :: LeafData -> SignPost -> MetaNode (To dir)
21:57:42 <elliott> data MetaContext where
21:57:44 <elliott> MCMInner :: Neighbours MetaCursor
21:57:46 <elliott> -> MetaCursor (From dir)
21:57:48 <elliott> -> SignPost
21:57:50 <elliott> -> MetaContext
21:57:52 <elliott> MCLeaf :: MetaCursor (From dir) -> SignPost -> MetaContext
21:57:54 <elliott> oerjan: somewhat of a resemblance
21:57:56 <elliott> s/MInner/Inner/
21:58:17 <Phantom_Hoover> And *then* you get to the second-order non-homogeneous differential equations god I hate second-order non-homogeneous differential equations.
21:58:29 <oerjan> elliott: yes, the difference is MetaNode has a distinguished exit
21:58:37 <elliott> ais523: an answer to the question "What exactly the error message is?" seen on a mailing list: "It's about glib lib."
21:58:44 <elliott> oerjan: right
21:58:57 <elliott> oerjan: it feels like i'd have half the types if everything took a list of directions to exclude on the type level :P
21:59:12 <Ngevd> Phantom_Hoover, I'm scared
21:59:13 <oerjan> heh
21:59:20 <Phantom_Hoover> Ngevd, YOU SHOULD BE
21:59:33 <Ngevd> > length "irregularwebcomic"
21:59:34 <lambdabot> 17
21:59:50 <Ngevd> That was irrelevant to this conversation
22:01:09 <elliott> oerjan: ok, you know what the next question is (or do you??)
22:01:46 * oerjan afraid
22:02:33 <elliott> oerjan: I need a space to play around with :P
22:02:49 <elliott> my leaf data is just String, so "" will work there, my IpId is just Int so that's easy, and my IpData is Double which can just be whatever
22:03:00 <elliott> what type do i want as the top-level "space with n cursors"?
22:03:34 <oerjan> MetaContext was sort of what i imagine as the "start-from-here" type
22:03:41 <elliott> ok
22:04:04 <elliott> oerjan: Leaf or Inner? :P
22:04:17 <Ngevd> Okay, if I ever say I'm going to install Haiku, can someone tell me I've already got the ISO and the image, and I need an SD card larger than 16MB
22:04:34 <oerjan> Leaf probably, since you would start on some actual befunge or what-it's-you're-doing cell spot
22:04:46 <elliott> oerjan: right
22:05:30 <elliott> oerjan: the SignPost should just be (Map.singleton 0 (Left pi)), right? if the IP ID is 0 and the data is pi
22:05:38 <oerjan> elliott: ah, might want a LeafData in the MCLeaf too
22:05:41 <elliott> ok :P
22:06:00 <oerjan> yeah i'd think
22:06:11 <elliott> alright, all I need is a MetaCursor (From dir) now
22:06:29 <elliott> data MetaCursor src where
22:06:29 <elliott> MCPlain :: PlainCursor src -> MetaCursor src
22:06:29 <elliott> MCPath :: MetaPath src dest -> MetaNode dest -> MetaCursor src
22:06:37 <elliott> oerjan: you'll never guess what the next question is
22:06:38 <oerjan> and since you're starting with only a cursor there, that MetaCursor should be MCPlain
22:07:22 <elliott> ok, and the type tells me I need PCFrom
22:07:30 <oerjan> MCPath only starts being used once you have two real cursors in different spots
22:08:06 <elliott> oerjan: hmm, I can get to the neighbours afterwards, but what should the PlainCursor of the same type that PCFrom wants be?
22:08:11 <elliott> oh, that's going upwards, right?
22:08:16 <elliott> as in, going "larger"
22:08:27 <oerjan> yeah
22:08:39 <elliott> oerjan: so it should be circular?
22:08:42 <oerjan> so From something
22:08:44 <elliott> because i have a completely empty space right now
22:08:49 <elliott> i.e.
22:08:51 <elliott> pc = PCFrom undefined pc
22:08:55 <elliott> PCFrom :: Neighbours1 PlainCursor dir
22:08:55 <elliott> -> PlainCursor (From dir)
22:08:55 <elliott> -> PlainCursor (From dir)
22:09:26 -!- Ngevd has quit (Quit: Goodbye).
22:09:54 <oerjan> well not entirely circular, things have types that change between the levels...
22:10:02 <elliott> oerjan: um that is impossible
22:10:04 <elliott> <elliott> -> PlainCursor (From dir)
22:10:04 <elliott> <elliott> -> PlainCursor (From dir)
22:10:06 <elliott> exact same type
22:11:01 <oerjan> oh hm so it is
22:11:28 <oerjan> i guess the level types got forgotten in the transition to this. maybe just as well :P
22:11:52 <elliott> oerjan: i'm not sure that would even work :P
22:12:03 <elliott> oerjan: it could be polymorphically recursive anyway i think
22:12:06 <oerjan> oh there's probably _some_ way
22:12:30 <elliott> ok, so now I need a (Neighbours1 PlainCursor dir)
22:12:43 <elliott> let's pick dir ~ NW :P
22:12:53 <elliott> so (Neighbours1 PlainCursor NW)
22:12:56 <elliott> Neighbours1NW :: t (To NE) -> t (To SW) -> t (To SE) -> Neighbours1 t NW
22:13:06 <elliott> oerjan: time for polymorphic recursion, right?
22:13:12 <elliott> (Neighbours1NW pc pc pc)
22:13:21 <elliott> oh, no!
22:13:23 <elliott> pc is a PCFrom
22:13:24 <elliott> I need a To
22:13:33 <elliott> PCTo :: Neighbours PlainCursor -> PlainCursor (To dir)
22:13:33 <elliott> PCLeaf :: LeafData -> PlainCursor (To dir)
22:13:47 <elliott> oerjan: ok, help me out here :P I want an infinite space with "" on all the leaves
22:13:48 <oerjan> i'm not sure i understand your Neighbors1 stuff
22:13:59 <elliott> oerjan: Neighbours1 t dir is just t (To dir') for all dir ~/~ dir'
22:14:15 <elliott> to abstract all the "twenty constructors because we have a neighbour for every other direction" crap
22:14:23 <oerjan> oh hm
22:14:37 <oerjan> elliott: there's an error there i think
22:14:42 <elliott> oh no
22:15:15 <oerjan> the dir in the second argument to PCFrom is the up dir, so should be unrelated to the others
22:15:16 <elliott> oerjan: i was curious indeed because it seemed like I either had to make a finite space or have no leaves
22:15:33 <oerjan> iiuc
22:15:42 <elliott> one second then
22:16:17 <elliott> PCFrom :: Neighbours1 PlainCursor dir
22:16:17 <elliott> -> PlainCursor (From dir')
22:16:17 <elliott> -> PlainCursor (From dir)
22:16:18 <elliott> oerjan: yus?
22:17:37 <oerjan> yeah
22:17:39 <elliott> test :: MetaContext
22:17:39 <elliott> test = LeafCtx "" mc (SignPost $ Map.singleton 0 (Left pi))
22:17:39 <elliott> where mc = MCPlain pc
22:17:39 <elliott> pc = PCFrom (Neighbours1NW pc' pc' pc') pc
22:17:39 <elliott> pc' :: PlainCursor (To dir)
22:17:40 <elliott> pc' = PCLeaf ""
22:17:43 <elliott> oerjan: that's an infinite space of ""s, right?
22:18:25 <oerjan> that's wrong though, the pc part
22:18:46 <elliott> oerjan: :(
22:19:00 <oerjan> you need to include the level as an Int argument or something, so you know how far to go _down_ again before hitting leaves
22:19:32 <oerjan> so mc = MCPlain (pc 0)
22:19:58 <elliott> oerjan: hmm, and what does pc look like then?
22:20:08 <ais523> what program are you discussing, btw? Shiro?
22:20:15 <oerjan> pc n = PCFrom (Neighbours1NW (pc' n) (pc' n) (pc' n)) (pc (n+1))
22:20:31 <oerjan> pc' 0 = PCLeaf ""
22:20:33 <elliott> ais523: yes
22:21:01 <elliott> oerjan: ok
22:21:10 <elliott> oerjan: pc' n?
22:21:21 <oerjan> pc' n = PCTo (pc' (n-1)) (pc' (n-1)) (pc' (n-1)) (pc' (n-1))
22:21:28 <oerjan> or something like that
22:21:42 <elliott> oerjan: (and out of curiosity, what kind of space did I produce with my erroneous version? it certainly /types/
22:22:29 <oerjan> a space where you go up just fine, but where going down from anywhere other than the "trunk" gives you a leaf _immediately_
22:22:33 <oerjan> i think.
22:22:43 <oerjan> *down to
22:22:53 <elliott> oerjan: ah.
22:22:58 <elliott> oerjan: that doesn't sound like normal 2d space :-)
22:23:06 <oerjan> indeed not :P
22:23:23 <elliott> oerjan: imagining that is hurting my head :P
22:24:09 <oerjan> it's like shrinking every quadtree region other than those containing your starting point into a single leaf
22:24:48 <elliott> test :: MetaContext
22:24:48 <elliott> test = LeafCtx "" mc (SignPost $ Map.singleton 0 (Left pi))
22:24:48 <elliott> where mc = MCPlain (pc 0)
22:24:48 <elliott> pc n = PCFrom (Neighbours1NW (pc' n) (pc' n) (pc' n)) (pc (n+1))
22:24:48 <elliott> pc' :: Int -> PlainCursor (To dir)
22:24:49 <elliott> pc' 0 = PCLeaf ""
22:24:51 <elliott> pc' n = PCTo (Neighbours (pc' (n-1)) (pc' (n-1)) (pc' (n-1)) (pc' (n-1)))
22:24:53 <elliott> oerjan: success
22:25:02 <oerjan> ah
22:25:22 <elliott> oerjan: I would use Integer, but... good luck allocating that much
22:26:07 <elliott> oerjan: ok, so now for the question that will make you _really_ hate me.
22:26:12 <oerjan> if you gave To and From type level integer arguments... >:)
22:26:23 <elliott> oerjan: how do I make the focused cursor go east? :-)
22:26:36 <oerjan> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
22:27:16 <oerjan> well, in this case you'd first go up, then To NE
22:29:02 <elliott> oerjan: so would it be MetaContext -> MetaContext?
22:29:08 <oerjan> i guess
22:30:02 <elliott> oerjan: reassuring :P
22:30:09 <oerjan> food ->
22:32:22 <Gregor> elliott: Don't read too much into this question, but which words are absolutely fundamental to Forth?
22:32:50 <elliott> Gregor: Forth as in "like ANS Forth", or "like /Forth/" as in "particularly high in Forthiness"?
22:32:58 <elliott> (colorForth is more /Forth/ than ANS Forth, but not very ANS Forth at all)
22:33:07 <Gregor> elliott: Basically Forth flavored.
22:33:08 <Phantom_Hoover> Heh, the sun's core produces about as much heat per cubic metre as a compost heap.
22:33:17 <elliott> Gregor: But take a look at jonesforth, and previous IOCCC entry -- what was it called -- fifth?
22:33:26 <elliott> Gregor: http://www.ioccc.org/1992/buzzard.2.design
22:33:28 <Gregor> elliott: But was it a JIT :P
22:33:38 <elliott> Gregor: See also other buzzard files in http://www.ioccc.org/1992/
22:33:43 <elliott> Gregor: And all Forths are JITs.
22:34:06 <elliott> Gregor: Erm, buzzard.2 that is.
22:34:11 <Gregor> elliott: They certainly ought to be, but if there's already been a JIT in IOCCC, URGGGGGGH
22:34:27 <elliott> And http://www.ioccc.org/1992/third of course.
22:34:31 <elliott> Gregor: Well, no.
22:34:32 <pikhq> Gregor: A threaded code JIT is a little bit different from what you're doing, of course.
22:34:37 <elliott> Gregor: buzzard is just a freaky-deaky little thing.
22:34:50 <Gregor> A threaded-code JIT ain't a JIT, it's a bytecode interpreter.
22:34:56 <pikhq> BAH
22:35:04 <pikhq> Thee and thy making more sense than I
22:35:06 <elliott> Gregor: A bytecode interpreter that doesn't have an interpreter loop...
22:35:10 <pikhq> s/Thee/Thou/
22:35:15 <Gregor> elliott: So?
22:35:27 <elliott> Gregor: An interpreter loop is sort of the defining feature of an interperter.
22:35:37 <Gregor> elliott: (I mean, it's good fun, but "So?" in the not-competing-with-my-niche sense)
22:35:44 <elliott> Gregor: Well, sure.
22:35:53 <elliott> Gregor: "Traditionally" JITting Forth is pretty heretical, anyway :P
22:36:08 <pikhq> elliott: Oh, it has an interpreter loop. Which has been placed at the end of every primitive. :P
22:36:12 <elliott> Gregor: Pretty sure first (buzzard.2) has an interpreter loop for the threaded code, anyway.
22:36:30 <Gregor> I was just thinking that really there's nothing at this point that's holding me to my particularly-bad language choice.
22:37:06 <elliott> Gregor: I think the judges might be unimpressed with "minimalistic Forth-like with most primitives implemented in itself", since that's exactly what FIRST/THIRD did so spectacularly :P
22:37:11 <elliott> And in under 500 bytes.
22:37:17 <elliott> (With indentation etc.!)
22:37:25 <elliott> Gregor: So, change your language, but probably not to something Forthy.
22:37:30 <Gregor> Fair 'nuff.
22:37:48 <pikhq> Go more functional.
22:37:59 <pikhq> (note: don't)
22:38:01 <elliott> I don't think his JIT would be any good at that :P
22:38:07 <Gregor> Indeed it would not.
22:38:16 <pikhq> elliott: He'd also want a GC if he wanted to do it right. :P
22:38:18 <elliott> Gregor: ...OTOH, a mini-Lispalike might be interesting :P
22:38:24 <Gregor> >_>
22:38:33 <elliott> Lisp isn't exactly a functional language anyway. But I realise you have biases :P
22:38:34 <pikhq> Aaaand, if you pull off a GC in the size restrictions, you are God.
22:38:45 <Gregor> Yeah, the GC is the real thing thar :P
22:38:50 <elliott> Ehhhhhh
22:38:55 <elliott> Lisp programs don't cons THAT much.
22:38:58 * Gregor taps his foot ...
22:39:09 <elliott> Especially if you offer mutation of conses.
22:39:09 <Gregor> Yeah, I'm gettin' awfully close to the size restriction as stands.
22:39:13 <Gregor> 1888 bytes at last count.
22:39:47 <elliott> Gregor: I still think if you can't impress people with an interesting language, impressing them with an end result is almost as good.
22:39:55 <elliott> i.e. Write a program that does something fancy :P
22:41:09 <elliott> Gregor: Do you manually turn full.c into jitchards.c?
22:41:11 <elliott> Harsh.
22:42:13 <Gregor> elliott: Uhhh, thusfar all I've done is selected areas of code in visual mode and G-Q in vim.
22:42:24 <elliott> X-D
22:42:39 <elliott> Gregor: Not true: You use 9<<25 in jitchards.c but W in full.c
22:42:53 <Gregor> elliott: I haven't updated jitchards.c in a while.
22:45:06 <elliott> Gregor: Whoops, accidentally forked jitchards :P
22:45:13 * elliott deletifies.
22:45:37 <Gregor> elliott: >_> Does bitbucket let me prevent that I wonder
22:45:45 <elliott> Gregor: It was privately, since I didn't futz with the boxes.
22:45:51 <Gregor> Ah
22:45:58 <elliott> Gregor: (It was only slightly "accidental" :P)
22:47:39 <elliott> Gregor: BTW, I would test with gcc 3 too >_>
22:48:05 <elliott> Gregor: I find it really hard to believe that IOCCC isn't run on some ancient IRIX box :P
22:48:17 <elliott> EVEN IF THEY DO HAVE A TWITTER
22:48:27 <Gregor> X-D
22:49:10 <elliott> Gregor: "On the Vax main is called with
22:49:10 <elliott> the calls instruction which uses the first word of the subroutine as a
22:49:10 <elliott> mask of registers to be saved. So on the Vax the first word can be anything."
22:49:19 <elliott> -- http://www.ioccc.org/1984/mullender.hint, the famous "main is a string" prorgam, referenced from the FAQ
22:49:22 <elliott> Gregor: That explains your VAX troubles :)
22:49:42 <Gregor> elliott: I fixed my VAX troubles (now I'm having different VAX troubles)
22:49:50 <elliott> VAX troublen.
22:53:03 <elliott> Gregor: Come on, laugh :'(
22:54:12 <elliott> Wow, IOCCC have a standard entry format :P
22:54:16 <elliott> As in, custom file format...
22:56:56 <elliott> "mentioning your name or any identifying information in the remark section (or in the C code for that matter) - we like to be unbiased during the judging rounds; we look at the author name only if an entry wins"
22:56:56 <elliott> Heh
22:57:23 <elliott> Gregor: Looks like you can't submit a makefile, just makefile lines
22:58:03 -!- Darth_Cliche has joined.
22:58:28 * Phantom_Hoover → sleep
22:58:29 -!- Phantom_Hoover has quit (Quit: Leaving).
22:58:38 <elliott> Ooh, they tell you to test on a UNIX or POSIX-conforming machine. Gregor: You're going to have to test it on OS X.
22:58:47 <elliott> Wait.
22:58:56 <Deewiant> Interix
22:58:57 <elliott> It says conforming, not "said to be conformant by people with money".
22:59:04 <elliott> Gregor: Your chances of fulfilling their guidelines are 0.
22:59:36 <elliott> "Your entry must compile with GCC and run under at least one flavor of UNIX (e.g. Linux or Solaris). To improve chances to win, it should work under both BSD and SysV style UNIX (think stty cbreak), and should not depend on endianness."
22:59:42 <elliott> Aww, "style".
22:59:46 <elliott> I was hoping they tested on real live SysV.
23:00:47 <olsner> what is stty cbreak and why would it be relevant for an ioccc entry?
23:01:19 <elliott> "$BSD = -f '/vmunix';
23:01:19 <elliott> if ($BSD) {
23:01:19 <elliott> system "stty cbreak /dev/tty 2>&1";
23:01:19 <elliott> }
23:01:19 <elliott> else {
23:01:19 <elliott> system "stty", '-icanon',
23:01:21 <elliott> system "stty", 'eol', "\001";
23:01:23 <elliott> }"
23:01:25 <elliott> -- ancient perl faq
23:01:27 <elliott> Presumably you have to do the latter on sysv
23:01:33 -!- DCliche has quit (Ping timeout: 260 seconds).
23:01:43 <elliott> IOCCC entries are allowed to call system()
23:01:56 <olsner> mmkay... the question is, what does it do? :)
23:02:33 <elliott> Puts the terminal into rare mode, methinks
23:02:42 <elliott> As in, ^C and the like still send signals, but apart from that it's raw and unbuffered
23:02:59 <elliott> So, useful for console tricks and the like
23:03:45 <elliott> http://www.opensource.apple.com/source/gnuzip/gnuzip-28/gzip/zmore.in oh my god, is this real
23:09:08 <pikhq> Funny, I call that "less".
23:09:28 <pikhq> Yay, LESSOPEN.
23:15:31 <elliott> hey oerjan
23:15:35 <elliott> EAST >:)
23:17:26 <elliott> ais523: i note that NEF might give you problems whenever you neeed a circular structure
23:20:34 <Gregor> <elliott> "Your entry must compile with GCC and run under at least one flavor of UNIX (e.g. Linux or Solaris). To improve chances to win, it should work under both BSD and SysV style UNIX (think stty cbreak), and should not depend on endianness." // nothing I do is especially OS-dependent.
23:20:40 <Gregor> elliott: I see no reason why it wouldn't work on SysV.
23:21:06 <elliott> More like System... SUCKS
23:23:08 <elliott> ais523: hmm, why does substat take both v and c?
23:23:12 <elliott> ais523: or is one of them always Error?
23:25:27 -!- augur has quit (Remote host closed the connection).
23:25:32 <ais523> it takes both v and c when substituting in a type 2 value; and v and error when substituting in a type 1 value
23:25:41 <ais523> to avoid code duplication
23:26:52 <elliott> ais523: wait, type 2 values have two values?
23:27:07 <elliott> hmm, substituting "in"
23:27:10 <ais523> wait, hmm
23:27:27 <elliott> ais523: do the two arguments to a type-2 function have the same number?
23:27:38 <ais523> elliott: yes, at definition site
23:27:41 <ais523> and which is used depends on context
23:28:02 <ais523> aha, what's happening is that substat is doing two substitutions simultaneously, one on c, one on v
23:28:02 <elliott> ais523: context being, the type it's used in?
23:28:07 <ais523> yep
23:28:10 <elliott> OK
23:28:21 <ais523> you can always tell what type something is from where it is in the program, and the two args always have different types
23:28:35 <ais523> the interp I pasted actually adds a suffix, "c" for type 1 or "v" for type 2
23:28:44 <ais523> (because suffixing numbers with numbers doesn't really work well)
23:28:57 * elliott thinks you should call the types c and v instead
23:29:12 <Gregor> elliott: OK, it seems my biggest VAX bug was outright stupidity.
23:29:37 <Gregor> elliott: Using e where I meant x, thereby making the place I'm JITting into point off into the text segment.
23:30:40 <elliott> I mean, c and v are much nicer names than 1 and 2. Probably.
23:32:38 <elliott> ais523: Actually I'm just going to call them c in v in my implementation.
23:32:40 <elliott> You can't stop me.
23:32:42 * elliott rebel
23:32:48 <ais523> fair enough
23:33:02 <ais523> 1 and 2, I find more memorable, because 1 args and 2 args
23:34:24 <elliott> ais523: (VarC 0) is always illegal in the body of a c-lambda right?
23:34:29 <elliott> because it only has one argument, of type V
23:34:45 <ais523> elliott: if 0 refers to the c-lambda itself, yes
23:34:58 <ais523> it's obviously legal if there are other lambdas in between, so that 0 has a different referent, and refers to a v-lambda
23:35:09 <elliott> that's not what "refers to" means, your terminology is awful
23:35:43 <ais523> err, refers to the variables of the c-lambda
23:35:46 <ais523> (which there is only one of)
23:36:35 <Gregor> elliott: ... ... actually it doesn't work on OS X :P
23:36:39 <elliott> Gregor: lol
23:37:36 <ais523> some sort of anti-JIT security feature?
23:37:59 <Gregor> ais523: Nope, just more nonsense.
23:38:23 <Gregor> ...
23:38:23 <Gregor> 00001f1a leave
23:38:23 <Gregor> 00001f1b ret
23:38:23 <Gregor> 00001f1c calll 0x00037f14
23:38:45 <Gregor> "I thought I'd just call this absolute address after returning. Made sense at the time. Good luck finding an epilogue here.
23:38:47 <Gregor> "
23:39:30 <monqy> callllllllll
23:39:47 <Gregor> monqy: Dood, it's gonna call the HELL out of that function.
23:40:07 <monqy> what IS that function
23:41:04 <ais523> presumably the function that gets called after a return statement returns
23:41:16 <ais523> it probably says "error: backwards return" or something like that
23:41:25 <elliott> error: help
23:41:38 <elliott> maybe os x has built-in coroutine support
23:41:44 <elliott> you can "ter" to jump to just after the last ret
23:41:53 <elliott> and it restores the registers and shit, by using a spaghetti stack
23:42:07 <elliott> and that's calling the "resumed non-coroutine" function
23:42:09 <elliott> makes perfect sense!
23:45:59 <elliott> ais523: hmm, I think substat is doing the work of about three functions :P
23:46:11 <ais523> yep, seems about right
23:46:17 <ais523> it was four or five earlier but I realised I didn't need some of htem
23:46:18 <ais523> *them
23:47:08 <Gregor> elliott: Out of curiosity, have you tried to run my JIT?
23:47:10 <elliott> ais523: you only ever need one function, actually!
23:47:15 <elliott> Gregor: Hell no; should I?
23:47:18 <Gregor> elliott: 'cuz so far all I really know is that it works on all these systems for me :P
23:47:56 <elliott> Gregor: I'm on boring x86-64/Linux/gcc 4.6
23:48:15 <elliott> Gregor: Try it on ZETA C
23:48:23 <Gregor> lol
23:48:27 <Gregor> Yeah, that'll work well.
23:48:36 <elliott> Gregor: Bignum int, pointers are cons pairs... what could go wrong?
23:49:45 <ais523> try it in bcc (a 16-bit C compiler)
23:49:49 <ais523> (that, umm, only understands K&R, I think)
23:50:24 <elliott> ais523: That's actually a decent idea
23:50:32 <elliott> Gregor: Do that (it has a flag to automatically run unprotoize before compilation)
23:51:01 <pikhq> elliott: sizeof(int) must be frightening
23:51:17 <Gregor> ais523: 16-bit won't ever work.
23:51:44 <ais523> TIL that pikhq is frightened of 2
23:51:54 <pikhq> ais523: Bignum int.
23:52:03 <ais523> oh, I see
23:52:09 <ais523> wrong context
23:53:52 <elliott> ais523: 2 is pretty terrifying
23:54:31 <Gregor> Incidentally, there are less-shitty i86 compilers out there :P
23:54:51 <Gregor> i.e. owcc (wow, it's amazing to categorize owcc as LESS shitty than anything)
23:54:58 <Gregor> s/i\.e\./e.g./
23:56:04 <elliott> ais523: so, the Exp inside a CallC -- sorry, the program inside a Call1 -- has a new binding in scope, right?
23:56:22 <elliott> and the programs inside a Call2 each have a new c binding and a new v binding with the same number (the same binding on each arm?)
23:56:29 <ais523> yep, I think so
23:56:50 -!- ais523 has quit (Quit: 2).
23:57:08 <elliott> /quit 2
←2011-11-15 2011-11-16 2011-11-17→ ↑2011 ↑all