00:23:43 -!- jpc has joined.
00:38:58 <augur> http://i47.tinypic.com/6puxi1.jpg
00:42:06 -!- Pthing has quit (Remote closed the connection).
00:46:04 -!- poiuy_qwert has joined.
00:53:51 -!- adam_d has quit (Read error: 110 (Connection timed out)).
00:56:50 -!- BeholdMyGlory has quit (Read error: 104 (Connection reset by peer)).
01:02:26 -!- MizardX- has joined.
01:05:03 -!- MizardX has quit (Read error: 104 (Connection reset by peer)).
01:06:22 -!- gfour has joined.
01:09:02 -!- MizardX- has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- Cerise has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- Deewiant has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- Asztal has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- comex has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- uorygl has quit (farmer.freenode.net irc.freenode.net).
01:09:02 -!- rodgort has quit (farmer.freenode.net irc.freenode.net).
01:09:03 -!- mycroftiv has quit (farmer.freenode.net irc.freenode.net).
01:09:03 -!- sebbu has quit (farmer.freenode.net irc.freenode.net).
01:09:03 -!- fizzie has quit (farmer.freenode.net irc.freenode.net).
01:09:04 -!- Gracenotes has quit (farmer.freenode.net irc.freenode.net).
01:09:04 -!- cheater has quit (farmer.freenode.net irc.freenode.net).
01:10:04 -!- gfour has quit ("Leaving.").
01:16:09 -!- poiuy_qwert has quit ("This computer has gone to sleep").
01:17:28 -!- fizzie has joined.
01:17:28 -!- sebbu has joined.
01:17:28 -!- mycroftiv has joined.
01:17:28 -!- rodgort has joined.
01:17:28 -!- uorygl has joined.
01:17:28 -!- comex has joined.
01:17:28 -!- Asztal has joined.
01:17:28 -!- Deewiant has joined.
01:17:28 -!- Cerise has joined.
01:17:28 -!- MizardX has joined.
01:17:28 -!- Gracenotes has joined.
01:17:28 -!- cheater has joined.
01:18:51 -!- Gracenotes has quit (SendQ exceeded).
01:36:24 -!- Gracenotes has joined.
01:41:51 -!- MizardX has quit ("zzz").
01:55:28 -!- coppro has quit (Remote closed the connection).
01:55:52 -!- coppro has joined.
02:07:09 -!- coppro has quit (Remote closed the connection).
02:07:33 -!- coppro has joined.
03:25:08 -!- Asztal has quit (Read error: 60 (Operation timed out)).
03:47:13 -!- poiuy_qwert has joined.
03:57:32 -!- poiuy_qwert has quit ("Leaving").
04:34:51 -!- soupdragon has joined.
04:55:34 -!- Slereah_ has joined.
05:03:03 -!- zzo38 has joined.
05:03:28 <zzo38> I think I fixed the license. http://zzo38computer.cjb.net/icosahedral/icoruma/license.irm
05:04:13 <zzo38> Note: The <#> is a formatting code for blockquotes
05:06:37 -!- Slereah has quit (Read error: 110 (Connection timed out)).
05:09:00 <coppro> zzo38: I'd suggest explicitly clarifying the GPL rule as to what you mean
05:09:19 <zzo38> coppro: How should I clarify it?
05:09:30 <coppro> zzo38: well, I'm not exactly sure what you mean
05:10:01 <coppro> do you mean you can incorporate the work or derivations there of into GPLed works, as long as attribution is given?
05:10:58 <zzo38> I don't really care that much about attribution, but the GPL and CC-BY-SA both require attribution anyways, so it might as well. But what I mean is basically as you said
05:27:25 <zzo38> What would be the best way to re-word it?
05:36:19 -!- Warriphone has quit (Read error: 110 (Connection timed out)).
05:46:51 -!- zzo38 has quit (Remote closed the connection).
06:24:08 -!- SimonRC has quit (Read error: 60 (Operation timed out)).
06:30:17 -!- coppro has quit ("I am leaving. You are about to explode.").
06:49:24 -!- oerjan has joined.
07:47:08 -!- oerjan has quit ("leaving").
07:50:00 -!- lament has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:00 -!- Warriphone has joined.
08:03:35 -!- augur_ has joined.
08:05:51 -!- Warriphone has quit (Remote closed the connection).
08:06:14 -!- Warriphone has joined.
08:09:56 -!- augur has quit (Read error: 110 (Connection timed out)).
08:20:56 -!- augur_ has quit (Read error: 110 (Connection timed out)).
08:26:13 -!- Warriphone_ has joined.
08:26:14 -!- Warriphone has quit (Read error: 104 (Connection reset by peer)).
08:26:15 -!- Warriphone_ has changed nick to Warriphone.
08:53:56 -!- FarOut has joined.
09:02:02 -!- FarOut has quit (Remote closed the connection).
09:13:57 -!- jpc has quit (Read error: 60 (Operation timed out)).
09:23:46 -!- SimonRC has joined.
09:33:27 -!- ehird has joined.
09:33:44 -!- lament has quit.
09:33:46 <ehird> Spot the difference!
09:36:59 <ehird> 16:38:58 <augur> http://i47.tinypic.com/6puxi1.jpg
09:36:59 <ehird> "In film you will find four basic story lines. Man versus man, man versus nature , nature versus nature, and dog versus vampire." —Steven Spielberg
09:40:12 <Slereah_> ehird : Avatar mostly reminded me of Fern Gully :
09:42:49 * ehird writes a code snippet to show why DYNAMIC-WIND is a pain, now that he's on da computaah
09:43:49 <ehird> ...after downloading Emacs
09:44:09 <ehird> git build from yesterday, I'm so cutting edge
09:49:19 <ehird> "The application Emacs quit unexpectedly."
09:49:24 <ehird> ok, then—not a nightly build
09:53:25 <ehird> Fathomic o-toodled
09:55:21 -!- Asztal has joined.
10:01:16 -!- anmaster_l has joined.
10:08:03 <ehird> this code is bugging in ways I'm pretty sure it's impossible to bug...
10:10:06 -!- MigoMipo has joined.
10:14:29 * ehird debugs it with SISC
10:17:22 <ehird> wait, no; that's a different issue
10:17:33 <ehird> aargh, this is driving me insane!
10:19:45 <ehird> Eh, I'll break my mind with the twisty interaction between CALL-WITH-CURRENT-CONTINUATION and DYNAMIC-WIND some other time.
10:21:17 * ehird downloads the six disks of Slackware 13.0
10:21:28 <ehird> On the first day of Christmas my browser sent to me
10:21:31 <ehird> Slackware thirteen oh
10:21:52 <ehird> And five hundred and ninety one megabytes in a file tree
10:22:09 <ehird> *Install dee one issoh
10:22:26 <ehird> I could, of course, just download the DVD file...
10:22:56 <ehird> Amusing that one of the most barebones distro has really large ISOs.
10:23:22 <ehird> Sigh. Fuck my slow internet connection. It's gonna take eight hours to download Slackware.
10:26:30 <ehird> The last three CDs are just sources.
10:43:46 -!- adam_d has joined.
10:45:54 -!- Gracenotes has quit ("Leaving").
10:51:28 -!- Pthing has joined.
10:52:02 -!- Gracenotes has joined.
11:03:03 -!- adam_d_ has joined.
11:04:39 <ehird> Hey; I'm computerised now. I can hack Haskell
11:04:42 <AnMaster> ehird, do you remember if 0.-2.0.29 for ick was same as 29.0.-2.0 in normal sense
11:04:54 * AnMaster is updating the ick package for arch
11:05:08 <ehird> AnMaster: ick to regular: reverse >> s/-/pre/
11:05:35 <AnMaster> ehird, just I'm having a headache here with a) versioning not increasing always b) pax
11:05:49 <ehird> AnMaster: Just use the release date internally
11:06:00 <AnMaster> ehird, for the package version. Hm maybe
11:06:11 <ehird> AnMaster: Does Arch let you do
11:06:20 <ehird> ver~somethingelse, where somethingelse is ignored? Or similar
11:06:21 <AnMaster> PKGBUILD (c-intercal) W: Description should not contain the package name.
11:06:26 <ehird> If so, just do releasedate~cintercalversionunmangled
11:06:45 <AnMaster> <ehird> ver~somethingelse, where somethingelse is ignored? Or similar <-- possibly, not that I know of though
11:06:48 <ehird> AnMaster: Clearly they forgot to make it case-sensitive.
11:06:56 <AnMaster> ==> ERROR: pkgver is not allowed to contain hyphens.
11:07:23 <AnMaster> ehird, there is already . in it
11:07:25 <ehird> 20100104.0.-2.0.29
11:07:35 <ehird> As long as you increase the major version to the release date every time, the rest won't matter
11:08:27 <AnMaster> ehird, well that - caused issues ;P
11:14:44 -!- adam_d__ has joined.
11:15:49 <soupdragon> I dont know wthe semantics are for a bunch of words I just use the identity function but that hardly makes sense
11:20:11 -!- adam_d has quit (Read error: 110 (Connection timed out)).
11:21:33 * ehird does fun dependent-ish programming in haskell's type system
11:21:52 <ehird> *Main> nonZero (undefined :: S Z) Full
11:21:53 <ehird> *Main> nonZero (undefined :: Z) Full
11:21:53 <ehird> <interactive>:1:25:
11:21:53 <ehird> Couldn't match expected type `NonZero Z'
11:21:53 <ehird> against inferred type `Full'
11:22:15 <soupdragon> im codin this article augur showed me using dependent types
11:22:18 <ehird> admittedly that's basically the same as using a typeclass, but i liiiike it
11:22:51 <AnMaster> -> Extracting ick-0.-2.0.29.pax.gz with bsdtar <-- why bsdtar I wonder
11:23:11 -!- adam_d has joined.
11:23:18 <ehird> soupdragon: http://hpaste.org/fastcgi/hpaste.fcgi/view?id=15624#a15624
11:23:22 <ehird> ch-ch-ch-check it out
11:23:38 <ehird> next step: a safe vector
11:24:48 <ehird> the snippet there can be done with typeclasses, but I like the agda-ish passing-the-condition
11:24:50 <soupdragon> I think you can do this with a GADT too?
11:25:21 <ehird> the nice thing about type families is... they're basically type functions
11:25:25 <ehird> if you ignore the class/instance lines
11:25:31 <ehird> it's just like a function definition in the type system
11:25:56 <soupdragon> write the variadic function sum (I 3) (I 2) (I 7) X = 3+2+7
11:26:01 -!- soupdragon has quit ("Leaving").
11:30:56 -!- adam_d_ has quit (Read error: 110 (Connection timed out)).
11:31:22 -!- adam_d_ has joined.
11:31:23 -!- BeholdMyGlory has joined.
11:33:48 <ehird> To enable textual disambiguation of overlapping instances, we declare the equalities together (by transferring GADT syntax to type synonyms):
11:33:48 <ehird> type TypeEq s t where
11:33:48 <ehird> TypeEq s s = TTrue
11:33:49 <ehird> TypeEq s t = TFalse
11:33:52 <ehird> haha fucking sweet
11:37:58 -!- adam_d__ has quit (Read error: 110 (Connection timed out)).
11:43:11 <AnMaster> ehird, that suggestion with release date won't work
11:43:24 <AnMaster> "Package versions should be the same as the version released by the author."
11:43:37 <ehird> it's either that or it doesn't work
11:44:01 -!- adam_d has quit (Read error: 110 (Connection timed out)).
11:44:07 <AnMaster> ehird, they suggested that minor "schema changes" might be okay. Which in this case would mean a boring 29.0pre2
11:44:18 <AnMaster> except doesn't pre1 come after pre2 there
11:46:01 <AnMaster> except would have to be written as decimal
11:46:34 <AnMaster> ehird, which might not always be exact.
11:47:03 <ehird> then put the base in the version number!
11:47:10 <ehird> say, as the last component
11:47:40 <ehird> well, 1/3 in base 3 is 0.1 right?
11:47:54 <ehird> so 29.0.-3 → 29.0.pre0.1.3
11:48:02 <AnMaster> ehird, but it won't sort correctly if different bases are used for different versions, right?
11:48:03 <ehird> where the .3 means "in base 3"
11:48:11 <ehird> AnMaster: shush you
11:48:21 <ehird> just do what debian does
11:48:32 <AnMaster> ehird, ~ isn't allowed it seems.
11:49:51 <AnMaster> ehird, anyway the arch dev I was speaking with gave up at the information that pre2 came before pre1. "<wonder> what the hell :D"
11:50:30 <ehird> just do what debian does, google to see how they mangle it
11:52:39 <ehird> class N n where toNum :: (Num m) => n -> m
11:52:39 <ehird> instance N Z where toNum _ = 0
11:52:39 <ehird> instance (N n) => N (S n) where toNum _ = 1 + toNum undefined
11:52:39 <ehird> need to fill out a type for the toNum call in N (S n) :(
11:53:37 <ehird> Could not deduce (N n1) from the context (Num m1)
11:55:06 <ehird> technically -fglasgow-exts makes the type system tc
11:55:09 <ehird> (can interpret lc)
11:59:49 <ehird> i remember i used to know how to write this funcn
12:23:18 <ehird> *Main> undefined :: Fib (Fact (S (S (S Z))))
12:23:23 <ehird> More jawsome than a speeding astronaut!
12:23:27 <ehird> AnMaster: Represent ↑
12:23:49 <ehird> AnMaster: Haskell, there, is computing fib(fact(3)) ... in the type system.
12:23:54 <ehird> As part of type checking.
12:24:00 <AnMaster> ehird, do it in C++ templates ;P
12:37:34 <AnMaster> hm isn't && and || non-original in C? as in, were added sometime after it become widespread but before C90
12:37:54 <ehird> i think they were added before it became widespread
12:37:58 <ehird> it used to be just & and |
12:38:05 <ehird> but && and || were added for associativity
12:38:10 <AnMaster> ehird, I'm just considering why & won't work very well
12:38:40 -!- augur has joined.
12:38:54 <AnMaster> for any values if(a | b) will take the same branch as if (a || b) (excluding possible side effects of evaluating a and b
12:39:11 <AnMaster> as in 2 & 1 won't be the same as 2 && 1
12:39:39 <ehird> it was purely for associativity
12:39:56 <AnMaster> ehird, so how did they solve the issue with 2 & 1 not being a logical and
12:40:20 -!- soupdragon has joined.
12:40:22 <ehird> by only doing bool & bool
12:40:40 <ehird> i didn't solve your gadt thing, but I did make the type system execute fib(3!)
12:40:47 <AnMaster> ehird, there are some functions in C that can return non-1/0 boolean values
12:40:56 <ehird> AnMaster: don't use them in ifs
12:40:56 <AnMaster> ehird, the stuff in ctypes.h comes to mind as a prime example
12:41:04 <ehird> if(foo() > 0 & ...)
12:41:17 <ehird> AnMaster: those are post-the-change
12:42:58 <ehird> type family Fact n
12:42:58 <ehird> type instance Fact Z = S Z
12:42:58 <ehird> type instance Fact (S n) = S n :* Fact n
12:42:59 <ehird> type instance Fib Z = Z
12:42:59 <ehird> type instance Fib (S Z) = S Z
12:43:00 <ehird> type instance Fib (S (S n)) = Fib (S n) :+ Fib n
12:43:02 <ehird> pretty cosy in type land
12:43:23 -!- FireFly has joined.
12:44:44 <ehird> i might solve it next
12:45:25 <soupdragon> AnMaster; write the variadic function sum (I 3) (I 2) (I 7) X = 3+2+7
12:45:26 <ehird> maybe if we wanted to define the terms so you could understand we would have
12:45:42 <soupdragon> no typeclasses or typefamilies or anything
12:45:56 <ehird> terms AnMaster does not understand there:
12:47:17 <soupdragon> well if you don't know haskell this puzzle wont be fun
12:47:34 <ehird> i think i've done basically the same thing before
12:47:38 <ehird> lemme finish playing with this first
12:47:45 <augur> ehird, lemme get your opinion on something
12:48:57 -!- Asztal has quit (Remote closed the connection).
12:49:33 <soupdragon> augur, is eat : (S\NP_sg)/NP the single correct category, and eat : (S\NP)\NP is just a hack that makes 'what does John eat' parse? (and so eat : (S\NP)\NP should be discarded)
12:49:43 <augur> i want to be able to draw diagrams in a webpage while having the HTML contain what seems to be some sort of code that describes the image
12:50:00 <augur> e.g. how wikipedia handles MathML or whatever
12:50:05 <augur> how do you think i should do this??
12:50:46 <augur> soupdragon: both are correct in the little shitty model of questions, they're just different words 'eat'
12:50:55 <augur> one for statements, one for direct object questions
12:51:17 <ehird> augur: wikipedia does TeX, not mathml
12:51:40 <ehird> and you want the unprocessed code to be valid HTML?
12:51:51 <ehird> is it being rendered before publishing or will some js magic transform it
12:52:02 <augur> thats part of the question i suppose
12:52:22 <ehird> well if you want the latter and don't care about the "theory" jsmath does that for latex
12:52:30 <AnMaster> ehird, fun thing: arch's clang package does not depend on llvm
12:52:32 <ehird> let's say you want to embed http://ditaa.sourceforge.net/ diagrams
12:52:40 <AnMaster> I haven't tried it without llvm installed. So not sure if it works or not
12:52:41 <ehird> and process it before publication
12:52:58 <ehird> <div class="diagram">
12:52:58 <ehird> ...ditaa source...
12:53:01 <soupdragon> augur, so can you unify them into something else using bluebird?
12:53:05 <ehird> transformed by some program to
12:53:20 <ehird> <div class="diagram">
12:53:20 <soupdragon> or eat just has to have two different categories?
12:53:21 <ehird> ...ditaa source...
12:53:26 <ehird> .diagram * {display:none}
12:53:35 <ehird> .diagram img {display:inline}
12:53:53 <ehird> is that an answer?
12:53:55 <augur> ehird: i was actually thinking about doing something from scratch as the kinds of diagrams i need are sort of custom
12:54:01 <ehird> http://ditaa.sourceforge.net/
12:54:06 <ehird> ditaa can handle anything you throw at it
12:54:37 <ehird> including colours, curves, every box style in existence, many types of lines, weird point things, overlapping diagrams, ...
12:55:16 <ehird> augur: if you have a stylesheet for non-graphical agents too that hides the img and shows the ditaa source, then the only unhandled case in my way is if the image doesn't load
12:55:19 <ehird> but that's pretty edge-case
12:55:22 <augur> can it handle automatically calculated tree diagrams, symmetry-preseving graph diagrams, and attribute-value matrices? :)
12:55:48 <ehird> ditaa was just an example
12:56:18 <ehird> Overlapping instances for Show ()
12:56:18 <ehird> arising from a use of `print' at <interactive>:1:0-29
12:56:19 <ehird> Matching instances:
12:56:19 <ehird> instance Show () -- Defined in GHC.Show
12:56:19 <ehird> instance (ToNum n) => Show n
12:56:19 <augur> i just want an idea of what sort of thing you think i should do -- JS rendered, JS calling out to a server-side lib, or server-side preprocessing
12:56:24 <ehird> soupdragon: restate your gadt problem again?
12:56:45 <augur> soupdragon: theyre just two different types
12:56:49 <ehird> augur: well you can avoid js in this case and that'd support non-js agents, speed up page loading, etc
12:56:55 <augur> you dont use bluebird on them, you just do it like normal
12:57:00 <ehird> so i wouldn't go for js, i'd go for a tool that preprocesses the html
12:57:09 <soupdragon> augur how does it motivate going from CG to CCG then?
12:57:31 <ehird> augur: i wouldn't do anything server-side either really
12:57:34 <ehird> are these pages otherwise static?
12:57:45 <augur> soupdragon: because you'd need to expand your lexical inventory for _every_ kind of extraction site
12:58:02 <ehird> just do % diagrender < foo.html > upload/foo.html
12:58:07 <ehird> on your local machine
12:58:23 <ehird> what do you mean, wha
12:58:24 <augur> oh you mean preprocess locally
12:58:38 <ehird> no need to cause server/client side load when it's a trivial preprocessing step
12:58:57 <augur> i dont want to have to be at my machine to fix a mistake or something tho
12:59:13 <augur> i want it to just be transparent, as if the browser supports it
12:59:13 <ehird> put the program on a usb stick :p
12:59:34 <soupdragon> the extraction site in that example is the word "does"?
12:59:38 <ehird> then do it with server side processing
12:59:54 <ehird> soupdragon: restate gadt prob plz
13:00:07 <augur> soupdragon: no, the extraction site is the direct object "john eat ___" -> "did john eat ___" -> "what did john eat ___"
13:00:10 <ehird> i just refuse to scroll up :)
13:00:24 <soupdragon> write the variadic function sum (I 3) (I 2) (I 7) X = 3+2+7
13:01:06 <augur> soupdragon: its actually significantly worse that that tho: because extraction can happen in a wide range of places, you would actually have to have to change the types in an insanely convoluted fashion, possibly even having an infinite number of types for _every single word_
13:01:12 <ehird> soupdragon: can I just support Integer?
13:01:15 <ehird> or do I have to use Num
13:02:03 <ehird> and can I define other auxiliary types?
13:02:32 <soupdragon> the rule is just that you don't use typeclasses or any of those things
13:02:33 <augur> ehird, so i take it that you would prefer server-side preprocessing to anything else
13:03:17 <ehird> soupdragon: i've done this before iirc, it involves a continuation argument I believe
13:03:33 <ehird> augur: well js is entirely superfluous here and isn't always available/introduces page loading lag/etc
13:03:38 <ehird> so server-side processing seems reasonable
13:03:59 <ehird> but if JS is more convenient to implement that's fine too
13:04:03 <augur> now i have another question
13:04:10 <ehird> your mom has another question
13:04:16 <augur> im basically going to be creating a custom graphics engine here, right
13:04:26 <ehird> augur: you don't need to do that
13:04:32 <augur> no, i do, trust me.
13:04:34 <ehird> soupdragon: also I can name it something other than sum can't I
13:04:42 <ehird> augur: no, I won't trust you, because you're wrong
13:04:44 <ehird> soupdragon: (prelude clash)
13:05:15 <augur> by custom graphics engine i mean basically something that lets me define custom drawing constructs that unfold recursively, etc.
13:05:27 <ehird> *Main> sumT (I 3) (I 2) (I 7) X
13:05:54 <augur> what i want to know is what sort of syntax i should give it
13:08:12 <ehird> augur: is there something wrong with using data structures instead of strings?
13:08:15 <ehird> that would be easier to manipulate
13:08:24 <ehird> *Main> sumT (I 3) (I 2) (I 7) X
13:08:35 <augur> ehird: well, data structures cant be encoded into HTML.
13:08:48 <augur> or written in page's source code, rather
13:08:54 <ehird> augur: put the diagram code into the html, and have a processor diagram→graphicsengine
13:09:07 <ehird> soupdragon: http://hpaste.org/fastcgi/hpaste.fcgi/view?id=15627#a15627
13:09:08 <augur> well thats what i was going to do, ehird :P
13:09:23 <ehird> augur: so you want syntax for the diagram stuff, not the underlying drawing engine, presmuably
13:09:23 <soupdragon> nice work that's exactly the solution I got
13:09:27 <augur> the question is what do you think the diagram code should look like
13:09:35 <ehird> soupdragon: i think it's pretty much the only solution
13:09:42 <ehird> unless you allow the use of things other than gadts
13:10:02 <augur> because its going to need to permit custom definitions of functions, etc.
13:10:14 <soupdragon> oh well I used an integer instead of continuation
13:10:35 <ehird> i just did continuations cuz i always did in my vararg stuff, to allow for more generic uses
13:10:46 <ehird> soupdragon: a challenge for you — implement:
13:11:12 <ehird> you may define types and typeclass instances
13:11:16 <ehird> but not define any typeclasses yourself
13:11:23 <ehird> you can use GADTs too if you want
13:11:32 <augur> any opinions, ehird?
13:11:37 * ehird writes down his solution
13:11:42 <ehird> augur: make it look functional-esque
13:11:49 <ehird> since it's essentially a functional program
13:11:59 <ehird> of type drawing instructions, right?
13:12:03 <ehird> your server side code is
13:12:12 <ehird> draw :: diagram → drawing
13:12:19 <soupdragon> ehird but that's impossible unless you typeclasses isn't i t
13:12:22 <ehird> so your input is of type diagram
13:12:30 <ehird> soupdragon: you can define typeclass instances but not typeclasses
13:12:48 <ehird> gimme an example you want to express, including a function
13:12:52 <ehird> and i'll show you what syntax i'd use
13:12:55 <ehird> you can use english
13:12:59 <augur> but as far as the syntax is concerned -- haskellish, rubyish, lisp-ish?
13:13:16 <augur> ok lets say i want to do a tree diagram, right
13:13:17 <ehird> well is ease of parsing a concern?
13:13:23 <ehird> if so, go for lisp, job done
13:13:42 <augur> no, i want it to be vaguely possible for others to use it tho
13:14:20 <augur> so suppose that [a b c] is a simply tree with "a" as the root node, and "b" and "c" as the two daughter nodes
13:14:37 <ehird> soupdragon: oh, and you may use FlexibleInstances
13:15:02 <augur> or where, lets say, [(a\nfoo) b c] is a tree where the root node has the two lines a, and foo, as the contents
13:15:32 <ehird> soupdragon: although, hmm, I think an ideal implementation might not
13:15:38 <ehird> also, you are allowed to use undefined
13:15:45 <ehird> but if you don't need FlexibleInstances you don't need to use undefined
13:16:31 <soupdragon> ehird I got for newtype Foo = Foo Integer
13:16:48 <augur> the code should be able to define a tree drawing algorithm so that drawing the tree [a [b c d] [e f g]] is done recursively
13:17:56 <augur> e.g. equivalent to like branch("a", [branch("b", [leaf("c"), leaf("d")]), branch("e", [leaf("f"), leaf("g")])])
13:18:23 <ehird> augur: erm, describe the drawing algorithm to me
13:18:26 <ehird> so that i can write the code for it
13:19:04 <ehird> soupdragon: ugh, my solution has run into an overlapping instances problem :)
13:19:06 <ehird> i know this is possib— ah!
13:19:12 <soupdragon> I can't do it because of flexible instance
13:19:19 <ehird> lemme try something
13:19:21 <ehird> I believe it is possible
13:20:58 <augur> ehird, i dont know. the point is that in this graphics language it should be possible to define something like leaf(_) or branch(_,_) that will be recursive functions that return little image objects that get composited together into larger units and so forth
13:21:18 <augur> i just need to know the general sort of syntax you think would make this clean and understandable
13:21:47 <ehird> well gimme an example drawing instruction
13:21:54 <augur> its going to need to be vaguely powerful, unfortunately, but
13:21:56 <ehird> your information is far too vague atm to give a good syntax
13:22:23 <augur> er. well ok, lets suppose we're doing a ruby-esque syntax for now, and we're defining some sort of tree algorithm
13:22:36 <augur> let me do this in a pastie
13:25:28 <ehird> soupdragon: maybe we should help each other, I keep honing on the solution but can't quite get to it
13:28:01 <ehird> soupdragon: I have:
13:28:03 <ehird> *Main> foo (Succ Zero) 1
13:28:04 <ehird> *Main> foo (Succ (Succ Zero)) 1 2
13:28:09 <ehird> so it's just a matter of somehow hacking this into a Num instance
13:28:12 <ehird> so we can have fromInteger
13:29:05 <ehird> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=15628#a15628
13:29:12 <ehird> if we can fill in fromInteger, it'll work
13:29:33 <ehird> note that that Eq instance is technically correct; as different N numbers have different types, and (==) takes two things of the same type, it's always true :)
13:29:44 <ehird> of course the other Num functions are blatantly undefined
13:30:45 <soupdragon> *Main> foo (1::Integer) (3::Integer) (6::Integer) :: Integer
13:30:53 <soupdragon> but I can't omit any of the annotations
13:31:08 <ehird> yeah that's just standard variadic stuff
13:31:18 <soupdragon> instance Num n => Num (Integer -> n) where fromInteger x y = fromInteger x + fromInteger y
13:31:24 <ehird> basing it on my thing is more likely to work, as it encodes the function type in the type
13:31:50 <ehird> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=15628#a15628 ;; can you think of a definition for fromInteger?
13:32:15 <soupdragon> maybe if you split it into two instances
13:32:17 <ehird> i think you'll need separate num instances
13:32:56 <ehird> *Main> fromInteger 0 :: N Integer
13:34:27 <soupdragon> augur cn you tell me some intro stuff for CCGs ? http://groups.inf.ed.ac.uk/ccg/publications.html is half dead
13:34:38 <soupdragon> something that will explain what's going on with eat ...
13:34:40 <augur> whats to tell you beyond what i wrote? :|
13:35:43 <soupdragon> I'm just confused about the step from CG to CCG, it seems to be motivated by some uglyness with eat - but even in CCG you still have two categories for eat?
13:35:55 <augur> no, you just have one
13:36:11 <augur> where did you get two from?
13:36:17 <ehird> augur: you haven't posted that pastie yet
13:36:22 <soupdragon> 'This solution is tremendously inelegant, however, because we’d have to posit a whole slew of different versions for the verb eat, just to handle the different kinds of sentences we get in English.'
13:36:37 <augur> soupdragon: that wasnt in CCG! that was just in CG! thats the point!
13:37:50 <ehird> instance Nish Integer
13:37:50 <ehird> instance Nish a => Nish (Integer->a)
13:37:50 <ehird> instance (Nish a) => Num (N (Integer -> a)) where
13:37:53 <ehird> this instance is proving difficult
13:38:02 <augur> ehird: http://pastie.org/767377
13:38:13 <ehird> incidentally Emacs is a lot nicer if you maximise it
13:38:51 <augur> i misstyped something
13:39:19 <AnMaster> ehird, oh? is it? both ways seems nice to me. Though I often use it in terminal, not X
13:39:21 <ehird> ok, so I'm just gonna write something and maybe fiddle with it and the like
13:39:24 <ehird> see if I can get something nice
13:39:34 <AnMaster> where "maximised" doesn't make any sense
13:39:44 <augur> ehird: im trying to use a sort of SICP graphics language y feel to it
13:39:58 <ehird> AnMaster: well for instance it splits vertically by default when maximised (assuming sane screen dimensions), and if you create three window thingies it splits like that
13:40:02 <augur> with functions like above, below, beside, etc, you know?
13:40:05 <ehird> instead of just sticking to two
13:40:09 <ehird> it feels more dynamic
13:40:19 <ehird> constraint solving?
13:40:33 <augur> well you remember how in SICP they have an imaginary image language where if you did
13:40:36 <ehird> and the engine figures out the positions
13:40:43 <ehird> augur: i haven't read sicp, gotta be honest.
13:41:11 <augur> it took two images a and b and just sort of image-concatenated them so that the resulting image was just b immediately below a
13:42:34 <ehird> augur: so in your tree model a branch can have N>0 children right?
13:43:01 <augur> sure lets pretend that trees must have non-zero children otherwise its a leaf
13:43:04 <ehird> what about the value in the branch, can that be any type?
13:43:20 <augur> anything thats drawable
13:43:24 <augur> string, number, another image
13:43:33 <ehird> but not every type is drawable, presumably
13:43:36 <ehird> for instance, functions
13:43:42 <ehird> good luck drawing a function
13:43:48 <augur> well thats up to the language
13:43:55 <augur> maybe if you tried to draw the function you'd get the source
13:43:55 <ehird> right, but the point is
13:43:58 <ehird> using haskell terminology
13:44:08 <ehird> Drawable a => a -> ...
13:44:30 <AnMaster> <ehird> good luck drawing a function <-- generate a flow diagram ;P
13:44:38 <ehird> an infinite flow diagram!
13:44:48 <augur> leaf is Drawable a => a -> Image
13:45:00 <augur> branch is Drawable a => a -> [a] -> Image
13:45:17 <ehird> technically, we could represent this as "everything is a branch"
13:45:28 <ehird> where branch=list of 1+ elems
13:45:30 <augur> sure but i dont wanna ;)
13:45:38 <ehird> branch = ["abc","def","blah"]
13:45:53 <ehird> augur: the reason I said this is
13:45:57 <ehird> Leaf :: Drawable -> Tree
13:45:57 <ehird> Branch :: Drawable -> List Tree -> Tree
13:46:02 <ehird> but then I realised, this is the same as just having Branch
13:46:08 <ehird> if the list is empty, it's a leaf
13:46:44 <augur> what i'd like is for this language to allow TeX esque library functions that can accept custom syntax
13:47:02 <ehird> custom syntax is rarely needed if your syntax is good enough
13:47:25 <augur> eg. in qtree you can just do \Tree [.a [.b c d] [.e f g]]
13:47:27 <ehird> augur: so, trees should be drawable, obviously, right?
13:47:37 <ehird> (amusing consequence: you can have leaves that are trees)
13:47:51 <augur> you can have NODES that are trees! :)
13:47:54 <ehird> tree() is the function that draws a tree, in yours
13:48:09 <augur> so you can, in principle, do like
13:48:25 -!- soupdragon has quit (Read error: 104 (Connection reset by peer)).
13:48:25 <ehird> also, you don't mind me slightly changing the semantics to try and get a nice syntax right ;)
13:48:33 <ehird> as in, same results
13:48:37 <ehird> but different in-language semantics
13:48:38 <augur> tree [tree([a,b,c]), tree([1,2,3)], tree([:x,:y:,z:])]
13:48:46 -!- soupdragon has joined.
13:48:46 <augur> change the semantics how you want
13:49:04 <augur> im just thinking the easiest way to do it is to have functions like above/below/beside/etc.
13:49:12 <ehird> sure, not changing that part
13:49:20 <ehird> just flexing my awesome language designer muscles to MAKE CODE BETTER
13:49:23 <augur> really, what i guess these would really be, is magic data structures
13:49:43 <augur> where like, text_cell(text, width=:auto, height=:auto)
13:50:06 <augur> is really just a constructor for something like, say, { :text => text, :width => width, :height => height }
13:50:41 <augur> below(a,b) is really just a constructor for say { :type => :below, :top => a, :bottom => b }
13:50:51 <soupdragon> augur I can't find a CCG parse of "What does John eat" :(
13:51:12 <soupdragon> I must have the categories of these words wrong.
13:51:22 <augur> and so forth, and the engine knows what it means to Show these things
13:52:11 <augur> soupdragon: lets do PMs so we dont flood the channel
13:54:31 <ehird> width = subtrees.inject(0) { |c,x| c + x.width }
13:54:43 <ehird> imo this is a flaw of your drawing system; with a constraint-based system this would be worked out automatically
13:55:25 <augur> sure, that really wasnt necessary actually :p
13:55:39 <augur> well no maybe not actually
13:55:54 <ehird> my crazy inner language designer is adding features never seen before to your language btw :P
13:55:56 <augur> for this particular example maybe
13:56:04 <ehird> that happens to serve the purpose of two features in other languages!
13:56:22 <ehird> specifically, it handles both haskell-typeclasses and haskell-data-declarations
13:56:58 <ehird> so in your thingy below takes a bunch of images and puts them one after another vertically
13:57:48 <augur> you'd have options for left aligned, centered, right aligned
13:57:55 <ehird> what's after, like below but horizontally?
13:58:08 <ehird> mind if I name that "beside"
13:58:40 <augur> im also thinking that the images, as composite data structures, should permit two things
13:58:43 -!- Asztal has joined.
13:59:07 <augur> general bounding boxes as well as n-recursive bounding rects
13:59:29 <augur> as well as path-level bounding shapes
13:59:41 <ehird> so just to check are you sure you don't want a constraint system :)
14:00:09 <augur> well maybe i do! i dont really know
14:00:35 <ehird> good, you do, i will incorporate that in my snippet
14:00:55 <augur> im going to start a github for this
14:00:59 <ehird> augur: basically all it means is that instead of working diirectly with images and each function like below laying them out itself,
14:01:12 <ehird> below actually just generates a list of constraints like this:
14:01:42 <augur> it should be arbitrarily many items, mind you
14:01:50 <ehird> { y.top >= x.bottom,
14:01:50 <ehird> z.top >= y.bottom }
14:01:52 <augur> tho i guess that can preprocess out
14:01:56 <ehird> see how that works?
14:02:08 <augur> maybe it should be = instead of >= tho
14:02:20 <ehird> well, "below" would simply mean
14:02:28 <ehird> if you didn't put anything in between later
14:02:41 <ehird> but the composability of constraints is the cool part, so.
14:02:47 <ehird> anyway, the constraint engine is basically like prolog except a lot simpler
14:02:59 <augur> howre the constraints composable now?
14:03:02 <ehird> it handles a bunch of constraints and works out what arrangements satisfy it
14:03:02 <augur> well how about this
14:03:07 <ehird> and picks the "best" one, per some metric
14:03:10 <augur> you come up with some ideas, and show why its cool
14:03:11 <ehird> and all other constraints just reduce to that
14:03:21 <ehird> augur: no i'm just going to assume you want it and code as if you do :)
14:03:37 <augur> right but show me why its nifty like that
14:03:59 <augur> because im not entirely sure im following your reasoning about why this is useful
14:04:31 <ehird> i can't really show an example off the top of my head, but when it's useful it is :P
14:04:50 <ehird> you never have to futz with widths or manual placement or anything
14:05:08 <augur> well, in some cases you might need to tho i think
14:05:11 <ehird> you just have to know, this has to be above this, this should be at the left edge of this, this should overlap this and this
14:05:16 <augur> but show me cases that eliminate this
14:05:17 <ehird> and the computaah figures it out for you
14:05:23 <ehird> no, i'm translating your pastie
14:05:27 <ehird> and if you keep talking i won't be able to
14:05:52 <ehird> what exactly is the point of your triangle call in branch()
14:05:55 <ehird> does it actually display anything
14:08:16 <augur> a triangle instead of branch lines, because im too lazy to figure out how the branchlines should be calculated :p
14:08:36 <augur> http://ironcreek.net/phpsyntaxtree/
14:08:38 <ehird> okay so this is tree drawing, psychedelia edition
14:08:44 <ehird> where you can't tell which branches are which :D
14:08:46 <augur> and notice the triangle under NP_2
14:09:07 <ehird> the triangle stops just before the children
14:10:03 <ehird> actually, (0,50) is kinda arbitrary, I think this will break if you have a nested tree... like any decent tree
14:11:06 <augur> it is indeed arbitrary
14:11:09 <augur> i just wanted a number
14:11:22 <ehird> let's say you have
14:11:48 <ehird> ["foo",["abc","def","blah"],["fff","ggg","zzz"]]
14:11:58 <ehird> the triangles under abc and fff will overlaap
14:12:05 <ehird> instead of being side by side
14:12:40 <augur> yes over the abc nodes right
14:12:49 <ehird> ok wait lemme draw
14:12:59 <augur> that is as wide as the whole image, with those two things just below it
14:13:11 <augur> (using the definition i gave for this, anyway)
14:15:37 <ehird> http://pastie.org/767427
14:19:06 <augur> actually, given how i defined it, it'd be more eh
14:20:12 <augur> http://pastie.org/767431
14:20:18 <augur> just by how i defined it
14:20:25 <ehird> ok, so it does handle that
14:20:28 <augur> because the upper triangle fully spans the lower images
14:20:47 <ehird> i need to look at your code more carefully, then translate it to constraints ;)
14:21:41 <ehird> augur: so the triangles are always 50 high?
14:21:48 <ehird> 50px? or does it scale
14:23:40 <augur> this is an unrealistic definition anyway
14:24:09 <augur> ideally the triangles should only be as wide as necessary to cover all the root nodes of the subtrees and no wider
14:28:09 <ehird> http://pastie.org/private/pzgtz8nyegfgpsbn1lcdq
14:28:09 <ehird> First attempt. Note something interesting here: width(subtrees) doesn't return a number, since it isn't known until draw time. Instead it returns an abstract object, so that in the end it turns into constraints like { triangle.p1.x == subtrees.width }.
14:29:13 <ehird> Er, *subtrees.width/2
14:29:46 -!- FireFly has quit ("Leaving").
14:30:39 <ehird> Also note the interesting below[] call. Since most function arguments are tuples, i.e. f(x,y) is f (x,y), we do variadic functions by instead passing a list.
14:30:52 <ehird> Cute syntax ensues.
14:32:26 <ehird> The syntax is a bit too (())ish for me.
14:32:37 <ehird> And it has my Mystical New Feature.
14:33:25 <augur> i cant do anything significant right now tho, im about to leave for the airport
14:33:34 <ehird> YOUR MOTHER is about to leave for the airport.
14:41:45 <ehird> soupdragon: any progress on the foo function?
14:42:45 -!- somebody_ has joined.
14:43:17 -!- soupdragon has quit (Nick collision from services.).
14:43:20 -!- somebody_ has quit (Remote closed the connection).
14:43:32 -!- soupdragon has joined.
14:45:30 <ehird> soupdragon: any progress on the foo function?
14:46:56 <soupdragon> you should just allow type annotations :)
14:47:59 <soupdragon> I cannot build a semantic domain without modelling untyped lambda calculus :[
14:48:08 <soupdragon> semantics of "and" is givin me problems
14:53:13 -!- MigoMipo has quit ("co'o rodo").
14:53:25 <ehird> soupdragon: fine, i allow type annotations, but your function didn't do what i asked
14:53:32 <ehird> the first parameter to foo is the *number of arguments it will take*
14:59:49 -!- augur has quit (Read error: 110 (Connection timed out)).
15:00:35 <soupdragon> I think there is a way to compute types from values like this using typeclasses
15:00:49 <soupdragon> not totally sure about the details but I saw some odd trick in #haskell one time
15:03:18 <ehird> I guess it wasn't clear
15:03:22 <ehird> but yeah, that's the idea
15:03:35 <ehird> you need to have some Num that you defined that lets the first argument be one of your types
15:03:43 <ehird> so you can encode what you need into the type
15:08:49 <ehird> http://plasmasturm.org/log/542/
15:08:50 <ehird> I wonder what a language based around caching would look like.
15:11:49 <ehird> "During the summer of 1981, my work on TeX began to consume so much time that I had to stop answering mail about The Art of Computer Programming. I began to set all such incoming mail aside and to send form-letter replies: ``Thanks, I'll get back to you soon.''
15:11:49 <ehird> Finally I was able to go through all the letters accumulated during a 15-year hiatus[…]" —Knuth
15:15:10 <soupdragon> im totally stumped wrt semantics of "and"
15:15:25 <soupdragon> it seems like the only way to tackle this is to use untyped lambda calculus
15:15:34 <soupdragon> but simple types are so much simpler....
15:28:09 <ehird> soupdragon: is it strongly typed LC?
15:28:16 <ehird> that's not TC, you need fix
15:28:34 <ehird> I wish http://arcanesentiment.blogspot.com/ posted more
15:28:44 <ehird> soupdragon: have you considered LC+dependent types
15:28:52 <ehird> (let's traverse the lambda cube until we find something that'll work :P)
15:29:13 <soupdragon> it was going really well with simple types, until AND came along and ruined it
15:31:04 -!- augur has joined.
15:31:32 <augur> soupdragon: whatve you been up to? :)
15:31:50 <augur> btw, for NP conjunction
15:32:13 <augur> you dont conjoin NPs directly but rather their lifted counterparts
15:32:26 <soupdragon> ehird, so the problem is you can do stuff like AND CAT DOG, but you can't have AND (\x -> LOVE x) (\x -> EAT x)
15:32:30 <augur> let NP' = S\(S/NP)
15:33:08 <ehird> soupdragon: so the basic issue is, x is like
15:33:11 <soupdragon> ehird, but if I set Sem ~ Sem -> Sem, then I model untyped lambda calculus and that means I don't know if anything terminates
15:33:20 <ehird> "I love it and I eat it"
15:33:20 <augur> and : (NP'\NP')/NP' = \q.\p.\r.p(r) & q(r)
15:33:28 <AnMaster> what was the command to explain a C type. It slipped my mind
15:33:29 <ehird> → AND (\x -> LOVE x) (\x -> EAT x)
15:33:31 <ehird> soupdragon: ah, I see
15:33:43 <ehird> soupdragon: (disturbing example)
15:33:47 <augur> soupdragon: is make sense?
15:33:59 <ehird> AnMaster: http://cdecl.org/
15:34:15 <soupdragon> augur: well my and is (X\X)/X, and that's just one instantiation right?
15:34:19 <ehird> soupdragon: so, are you averse to introducing typeclasses?
15:34:26 <AnMaster> ehird, someone ported it to js?
15:34:32 <ehird> AnMaster: it's ajax i think
15:34:35 <augur> soupdragon: indeed, thus we have a big of a tricky thing dont we!
15:34:50 <ehird> soupdragon: i'd model this as
15:34:50 <ehird> instance AND Sem where AND = ...
15:34:50 <augur> atleast if you want consistent semantics
15:34:51 <ehird> instance AND a => AND (Sem -> a) where AND = ...
15:35:02 <ehird> soupdragon: or, if you want to introduce dependent types...
15:35:13 <augur> you can let it be what it is, and force conjunction to be, semantically, (a -> b) -> (a -> b) -> (a -> b)
15:35:20 <ehird> you could have IsSemType
15:35:20 <augur> this would _force_ NPs to type-lift
15:35:57 <soupdragon> augur, so the semantics of Mary loves cats and dogs would be and(love(mary,cat),love(mary,dog)) ?
15:36:22 <ehird> soupdragon: or, here's an idea
15:36:37 <ehird> (\x -> AND (LOVE x) (EAT x))
15:36:54 <augur> for verbs you'd just conjoin the verbs by forking over &
15:36:58 <ehird> you could do that programmatically and the like really
15:37:10 <augur> with cats and dogs, you turn the nouns into functions that you can fork over &
15:37:17 <ehird> in applications, take all functions and replace them with their bodies, then add their parameters to the whole expression
15:37:58 <augur> soupdragon: if you want to make a single system that will uniformly handle a large chunk of a language, tho, it becomes _INCREDIBLY_ tricky
15:38:47 <ehird> I wonder if you could make a language based on functions bubbling up like that
15:38:47 <augur> Paul Pietroski has whats called a conjunctivist model
15:38:54 <augur> so what we're using right now is a functionist model
15:39:02 <ehird> as in, f (\x -> ...) turns into (\x -> f (...)), always
15:39:03 <augur> where everything is function application
15:39:31 <augur> ehird -- ive thought of things roughly like that
15:39:45 <augur> only slightly reverse
15:40:33 <augur> soupdragon: pietroski's approach is one in which the only semantic composition rules are conjunction of predicates
15:40:41 <augur> and conjunction-over-closure of predicates
15:40:43 <ehird> plus = \m,n. m SUCC n
15:40:46 <soupdragon> augur I just bookmarked a search for it
15:40:56 <ehird> plus = \m,n. m (\n,f,x. f (n f x)) n
15:41:00 <augur> eat = \x.eating(x)
15:41:17 <ehird> plus = \m,n,n',f,x. m (f (n' f x)) n
15:41:27 <augur> dance = \x.dancing(x)
15:41:28 <ehird> god knows what that does
15:41:40 <augur> 'eating and dancing' ~ \x.eating(x) & dancing(x)
15:41:53 <augur> well, eat and dance*
15:42:27 <augur> John eats and dances = \x.eating(x) & dancing(x) & Ey[actor(x,y) & John(y)]
15:42:33 <ehird> the model soupdragon said
15:42:40 <ehird> AND (\x.LOVE x) (\x.EAT x)
15:42:42 <ehird> doesn't even make sense
15:42:47 <ehird> because the two arguments could differ
15:43:06 <augur> ehird, actually you can make it work like in a pietroskian system
15:43:19 <augur> where the _participants_ of actions are not expressed as in eat(John,pizza)
15:43:37 <augur> but rather as in eat(e) & eater(e,John) & eaten(e,pizza)
15:43:44 <augur> where e is 'the event of eating'
15:44:26 <augur> Donald Davidson proposed this account so that statements like "John ate the pizza quickly" can make some amount of sense
15:44:29 <augur> if semantically this was just
15:44:35 -!- MigoMipo has joined.
15:44:37 <augur> quickly(ate(John,pizza))
15:44:44 <augur> and if ate(John,pizza) == true
15:44:47 <augur> then this is quick(true)
15:44:49 <augur> which is nonsensical
15:45:10 <augur> because it "means" the same thing as quickly(danced(Susan)) if danced(susan) == true
15:45:28 <augur> so davidson said, lets just use variables that denote the event or action
15:45:50 <augur> and you get quickly(e) & eating(e) & eater(e,John) & eaten(e,pizza)
15:45:57 <soupdragon> but can't quickly(ate(John,pizza)) make sense?
15:46:07 <augur> not if you have referential transparency
15:46:15 <augur> imagine this haskell
15:46:27 <soupdragon> suppose ate(John,pizza) = a video of john eating pizza
15:46:27 <augur> and ate(John,pizza) is of type Thing -> Thing -> Bool
15:46:39 <soupdragon> then quicky(a video of john eating pizza) = a video of john eating pizza played at 2x speed
15:46:59 <augur> sure, but then you'd need it to be of type Thing -> Thing -> Thing
15:47:09 <augur> and in normal logic, everything is taken to be ... -> Bool
15:47:25 <augur> but thats ok right
15:47:38 <augur> because if ate(John,pizza) is Thing -> Thing -> Event
15:47:48 <augur> we can make it logicy
15:47:51 <soupdragon> the thing with quicky(e) & eating(e) ... is sort of like a constraint program, at least superficially
15:48:11 <augur> by doing ate`(John,pizza,e) :: Thing -> Thing -> Event -> Bool
15:48:13 <AnMaster> soupdragon, it seems slightly similar to predicate logic to me
15:48:22 <augur> AnMaster: it IS predicate logic :p
15:48:30 <AnMaster> augur, oh why didn't you say that
15:48:38 <soupdragon> ate`(John,pizza,e) :: Thing -> Thing -> Event -> Bool -- aha!!!
15:48:39 <augur> soupdragon: and ofcourse this just makes it obvious that you've got this extra event variable
15:48:44 <AnMaster> augur, I thought that no one would discuss something as trivial as that in here ;P
15:48:55 <augur> with ate :: Thing -> Thing -> Event, you'd end up doing stuff like
15:49:09 <augur> let e = ate(John,pizza) in quickly(e) & in_the_kitchen(e)
15:49:16 <augur> AnMaster: the type for things, people, stuff, etc.
15:49:31 <augur> but notice, soupdragon, that you're still, ultimately, predicating of the event
15:49:49 <AnMaster> augur, but what is the type of quickly?
15:49:57 <augur> AnMaster: Event -> Bool
15:50:13 <AnMaster> augur, can you describe those in a "meta"-way
15:50:13 <augur> ate` with the davidsonian account is Thing -> Thing -> Event -> Bool
15:50:47 <augur> AnMaster: you can make quickly() a special-form of your logic, in the same way that cond is a special form of lisp
15:50:57 <augur> you could make _Everything_ special forms
15:51:20 <augur> but its nicer if we can bring our knowledge of pred-calc to bear on this
15:51:26 <AnMaster> augur, I haven't followed the entire convo here, so not sure of the scope of what you try to describe. But I was considering something like "ate is the past tense of eat"
15:51:30 <augur> i mean, if you have special forms, you have to define a whole new logic
15:51:34 <augur> its much nicer to just use what we have
15:51:45 <AnMaster> of course I guess they are then thinks
15:52:03 <augur> ate-is-the-past-tense-of-eat can actually be seen as like
15:52:12 <augur> "ate" is really two things
15:52:28 <augur> eat = \e.eating(e)
15:52:44 <augur> conjoining them, eat-ed = \e.eating(e) & past(e)
15:52:56 <augur> and thenw e just say that the morphology of english turns eat-ed into ate
15:53:01 <augur> ok im off for the flight guys
15:53:06 <ehird> AnMaster: It's not predicate logic, it's linguistics.
15:53:08 <ehird> They're just isomorphic.
15:53:12 <AnMaster> augur, eating implies "right now" iirc. What about "I often eat pasta but right now I'm eating spinach"
15:53:25 <soupdragon> that's awesome putting morphology into it
15:53:57 <AnMaster> augur, feel free to add in "ate" there as well ("and yesterday I ate nothing")
15:54:43 <AnMaster> soupdragon, what about "eating fruit is good for you", not "currently" there
15:55:36 <AnMaster> soupdragon, English is ambiguous. This would probably have worked better with lojban or something
15:56:11 <soupdragon> so what I wanted to ask about was.. backtracking a bit
15:56:34 <soupdragon> I have the rule and : (X\X)/X (X is a variable)
15:57:02 -!- oerjan has joined.
15:57:40 <soupdragon> this idea about bubbling in the semantics, AND f g being written as \x.AND (f x) (g x) could be done by restricting the variable X to a ground type {N,NP,PP,S}?
15:58:09 * AnMaster is wondering why these two programs listing almost right after each other render with different letter spacing
15:58:15 <soupdragon> everything whos interpretation is typed Sem
16:04:10 -!- MigoMipo has quit (Remote closed the connection).
16:07:36 <soupdragon> you know it's pretty hard to build these derivation trees by hand
16:09:55 <ehird> AnMaster: lol@"this would have worked better with lojban"
16:09:59 <ehird> this is standard linguistics, dude
16:10:04 <ehird> it works perfectly well for english
16:13:05 -!- augur has quit (Read error: 113 (No route to host)).
16:13:48 <AnMaster> ehird, so what type or whatever is the -ing ending?
16:13:58 <ehird> why are you asking me
16:14:06 <ehird> ask augur, he's the linguist
16:15:43 <AnMaster> ehird, since you indicated it worked quite well in English
16:15:49 <AnMaster> <ehird> AnMaster: lol@"this would have worked better with lojban"
16:15:49 <AnMaster> <ehird> this is standard linguistics, dude
16:15:49 <AnMaster> <ehird> it works perfectly well for english
16:16:04 <AnMaster> ehird, so I assume you know how it works, or can't you back up your claim?
16:16:18 <ehird> you were saying that formally representing english is unreasonable, and lojban would be a better choicee
16:16:28 <ehird> i provided a counterargument, being:
16:16:31 <ehird> the ENTIRE FIELD OF LINGUISTICS
16:17:12 <pikhq> I thought it clear that formally representing natural languages (such as English) was effing hard, but not too unreasonable.
16:17:20 <pikhq> (as demonstrated by it having been done)
16:17:29 <ehird> It's not effing hard
16:17:31 <ehird> It's basic linguistics
16:17:36 <soupdragon> I'm trying to get a derivation of John loves and Mary hates pizza
16:17:45 <Slereah_> soupdragon : It is a queer bird
16:17:45 <soupdragon> such that and is used only with ground cats
16:17:52 -!- poiuy_qwert has joined.
16:18:06 <pikhq> ehird: ... I may be calling linguistics effing hard. :P
16:18:15 <ehird> your mom is effing hard
16:18:16 <soupdragon> what am I even asking this here I have the mockingbird book next to me :(
16:18:20 <ehird> i suppose that implies she's a hermaphrodite
16:18:21 <oerjan> soupdragon: S combinator is ap
16:19:15 <oerjan> liftM is not the same as ap
16:19:39 <pikhq> Sure enough: ap = liftM2 id
16:19:41 <oerjan> it's the same as fmap or <$>
16:20:09 <pikhq> I was... Not thinking straight.
16:20:22 <oerjan> liftM2 id is not = liftM
16:20:34 <soupdragon> on fig. 28 <http://www.wellnowwhat.net/blog/?p=294> and is used with X := S/NP
16:20:47 <soupdragon> but I need to re-derive it such that X is one of {N,NP,PP,S}
16:23:03 <oerjan> soupdragon: otoh, your Q is liftM2, i think
16:23:37 <oerjan> or was that how you got it in the first place
16:25:32 <soupdragon> well the thing is might be on the wrong track all together
16:25:58 <soupdragon> I was thinking of Qafg, but maybe it's better to find some < and > such that Qafg = f<a>g
16:27:05 <soupdragon> (John loves and Mary hates) $ pizza = John loves pizza and Mary hates pizza
16:28:28 <oerjan> < is flip (<$>) i think
16:28:47 <oerjan> i don't recall that having a name
16:29:47 <oerjan> there is also the on function
16:30:37 <oerjan> (op `on` f) x y = f x `op` f y
16:37:31 <soupdragon> maybe I should implement the parser then run it on this... and I won't have to work so hard trying to figure it out
17:00:22 -!- ehird has quit.
17:01:54 -!- lament has joined.
17:10:14 -!- ehird has joined.
17:10:23 <ehird> acquire ten dubloons
17:10:56 <ehird> John loves and Mary hates → (\x. AND (LOVES JOHN x) (LOVES MARY x))
17:11:08 <ehird> or LOVES x JOHN/MARY, w/e
17:11:34 <soupdragon> hard to actually find a derivation that parses John loves and Mary hates
17:11:46 <soupdragon> unless you allow AND (LOVES JOHN) (LOVES MARY)
17:12:16 <soupdragon> I might need some generalized bluebird or something
17:12:27 <soupdragon> apparently there's an algorithm for this
17:13:40 -!- lament has quit.
17:17:53 <ehird> if you have a function where a non-function is expected in an expression
17:17:58 <ehird> extract the function to the expression
17:18:14 <ehird> so AND (LOVES JOHN) (LOVES MARY) would turn into (\x -> AND (LOVES JOHN x) (LOVES MARY x))
17:18:47 <ehird> do it before typechecking
17:18:56 <soupdragon> there's no such thing as before typechecking :P
17:20:35 <oerjan> so AND needs to be applicatively overloaded? :)
17:22:01 <oerjan> hm wait that won't work, the base case doesn't fit
17:22:36 <soupdragon> im not even sure really I understand what hmmm
17:24:03 <soupdragon> the thing is... and = \pq.(p,q) : (X\X)/X only makes sense when X is ground
17:24:33 <soupdragon> and = \pq.\x.(px,qx) : ((X/A)\(X/A))/(X/A)
17:24:48 <soupdragon> and = \pq.\xy.(pxy,qxy) : ((X/A/B)\(X/A/B))/(X/A/B) ...etc
17:25:00 <soupdragon> dammit this just doesn't fit in with the rest of the framework
17:28:11 <AnMaster> hm does anyone know if openmp is just suited to number-crunching style workloads. Rather than, say, different threads doing different things, sometimes idling (think a server with threads, or a GUI program with backend threads and GUI threads)
17:28:19 * AnMaster suspects ehird is most likely to know
17:29:26 <ehird> OpenMP seems number-crunching oriented to me. Use pthreads to clone Plan 9/Go's thread API; that'd keep you sane.
17:29:47 <ehird> (Using pthreads directly is on my list of Ten Ways to Torture Your Mortal Enemies In Hell.)
17:32:07 <AnMaster> ehird, pthreads seems quite a pain yeah
17:32:32 <AnMaster> ehird, also what about *implementing pthreads*
17:32:44 <ehird> pthreads is very low level.
17:32:50 <ehird> Anyway, Plan 9/Go's thread API is *really* nice.
17:35:56 <AnMaster> anything worse than "use pthreads"
17:37:06 <AnMaster> ehird, is the list even specified in full ;P
17:37:14 <ehird> Abstract operations of Plan 9/Go's threading API: spawn { code } — run code in a new thread. make_chan(type[, bufsize]) — return a new channel containing values of type. send(chan, val) — send val to chan. If the channel has a bufsize, and the buffer of that size is not full, append to that buffer; otherwise, block until a recv() happens. recv(chan) — receive a value from chan.
17:37:42 <ehird> Well, if you have a global you can mutate it in two threads at once.
17:37:46 <AnMaster> while dirty, in some specialised workloads it performs much better
17:37:48 <ehird> But that would be dumb.
17:37:53 <ehird> You can do it if you want, though.
17:38:00 <AnMaster> ehird, I'm thinking merge sort with multiple threads
17:38:07 -!- virtue has joined.
17:38:15 <ehird> So we can use channels as completion signals:
17:38:15 <ehird> c = make_chan(bool); spawn foo(c); recv(c); /* assuming the value doesn't matter */
17:38:22 <ehird> Or to return the results of computation (obvious)
17:38:31 <ehird> We can have multiple channels per thread
17:38:34 <ehird> And multiple threads per channel
17:38:36 <AnMaster> ehird, as for those globals, could you store a pointer to a malloced block in there?
17:38:44 <ehird> AnMaster: Sure; they're regular threads.
17:38:47 <ehird> Same memory space and everything.
17:40:07 -!- virtue has left (?).
17:41:17 <ehird> chan(int) workers[x][y];
17:41:17 <ehird> for(x=0;x<w;x++) for(y=0;y<h;y++) {workers[x][y] = make_chan(); spawn pixel(x,y,workers[x][y]);}
17:41:17 <ehird> for(x=0;x<w;x++) for(y=0;y<h;y++) pixels[x][y] = recv(workers[x][y]);
17:41:18 <ehird> ↑ e.g. mandelbrot or other embarrassingly parallel task
17:41:56 <ehird> you could actually use the spawn syntax in gcc
17:42:35 <ehird> #define SPAWN(x) void _f(void) { x; }; spawn(_f)
17:44:36 <AnMaster> ehird, hm so malloc() there is thread safe?
17:44:52 <ehird> Depends on if your libc's malloc is thread safe, doesn't it?
17:45:12 <ehird> You can do whatever you want inside a thread.
17:45:34 * ehird tries to find the Go parallel mandelbrot to translate it to C+Gothreads
17:45:38 <ehird> (technically goroutines)
17:46:02 <ehird> also, since the threads are used very lightly — e.g. for every pixel in that mandelbrot — starting a 'real' thread for each one may not be so good
17:46:10 <ehird> not sure how much overhead pthreads has
17:46:25 <ehird> is it reasonable to start 100,000,000 pthreads?
17:46:32 <ehird> (to generate a 10,000x10,000 mandelbrot)
17:47:40 <ehird> AnMaster: oh and btw, this concurrency model is just the pi calculus
17:48:53 * ehird wonders if returning an array is like returning a struct, or like returning a pointer
17:48:55 <AnMaster> <ehird> Depends on if your libc's malloc is thread safe, doesn't it? <-- well the plan9 one I meant
17:49:01 <ehird> knowing c's retarded array handling, probably the latter *sigh*
17:49:24 <AnMaster> ehird, as for returning array. Is that allowed?
17:49:36 <AnMaster> well, for fixed size it might be
17:49:39 <pikhq> ehird: That concurrency model is quite nicely simple.
17:50:30 <AnMaster> ehird, isn't a struct returned as a pointer to a caller allocated space on stack for it. As in a pointer to it is passed as a hidden extra argument in %rax or somewhere (forgot where)
17:50:45 <ehird> struct is returned on the stack i believe
17:50:57 <ehird> i.e. returning struct{int a,b;} is like returning two values (int,int)
17:51:24 * ehird wonders how to declare returning an array
17:51:28 <ehird> int[width][height] foo()?
17:51:37 <ehird> int foo()[width][height]?
17:51:41 <ehird> is it even possible?
17:52:30 * ehird just requires the caller to pass in a pointer :P
17:53:16 <Deewiant> In C? No, you can only return a pointer or a struct
17:53:48 <ehird> hmm... is it possible, given a [][], to turn that into a ** reasonably? &ary doesn't work, it would produce *** i think
17:53:57 <ehird> just passing it to a func will copy it
17:54:23 <Deewiant> AnMaster: I meant, in place of an array
17:56:40 * ehird comes up with an evil hack to do parameterised types in c
17:57:52 <ehird> hmm... foo##__typeof__(3) won't produce fooint, will it; darn
17:58:05 <ehird> #define TUPLE(t) struct _tuple_##t {t a; t b;}
17:58:06 <ehird> #define NEW_TUPLE(t,a,b) ((struct _tuple_##t){a,b})
17:58:18 <ehird> TUPLE(int) foo = NEW_TUPLE(int, 1, 2);
17:59:47 <lifthrasiir> ehird: isn't it a pair, or equivalently, 2-tuple?
17:59:59 <ehird> I'm just using the Haskell terminology /shrug
18:02:12 <ehird> lol @ plan 9 thread function: proccreate
18:03:41 <mycroftiv> ehird: its BDSM too, first you bind, then you mount, then you proccreate
18:04:17 -!- adam_d_ has quit (Read error: 110 (Connection timed out)).
18:05:16 <ehird> mycroftiv: annoying that plan 9 does it letting you only pass a single void * as the functions arg
18:06:20 <mycroftiv> ehird: nah remember that C often doesnt even try to deal with your fancy 'types'
18:06:27 <ehird> yes, but if you want to pass two values
18:06:49 <ehird> #define SPAWN(x) ({ void _spawned_proc(void) { (x); }; spawn_proc(_spawned_proc); })
18:06:50 <ehird> ↑ inelegant and bloody convenient
18:07:28 <mycroftiv> you make your struct with as many vars as you want to pass, malloc it, fill it up, cast it to void, send it to your proccreate, then cast it back to its real form
18:07:43 <ehird> yeah, see, that's less convenient than f(x,y)
18:08:11 <mycroftiv> i almost could see going the other way in a language
18:08:22 <ehird> SPAWN(send(workers[x][y], calc_pixel(x, y)));
18:08:29 <ehird> try that with your dumb function!
18:10:51 <oerjan> ehird: i don't think the tu- in tuple has anything to do with two. it's a generalization from quintuple, sextuple (possibly more?) to n-tuple
18:11:18 <oerjan> and triple is just the original case for 3
18:12:02 <ehird> tuple, triple, quadruple always seemed reasonable to me
18:12:11 <oerjan> i think it's formed in latin like quintus (5th) + -plex
18:12:48 <ehird> writing this mandelbrot is fun
18:20:12 <AnMaster> <mycroftiv> you make your struct with as many vars as you want to pass, malloc it, fill it up, cast it to void, send it to your proccreate, then cast it back to its real form <-- not allocate it on the stack? XD
18:20:33 <AnMaster> ehird, so make a varargs wrapper for spawn
18:20:33 <ehird> That would cause a wasteful copy.
18:20:47 <ehird> OTOH, overhead(copy) < overhead(malloc).
18:21:00 <ehird> AnMaster: #define SPAWN(x) ({ void _spawned_proc(void) { (x); }; spawn_proc(_spawned_proc); })
18:21:29 <ehird> It's legal GNU C .
18:21:34 <ehird> It's a statement expression.
18:21:51 <ehird> ({ a; b }) is like do { a; b } while (0), except it's usable as an expression.
18:21:55 <ehird> The return value is the last statement.
18:22:11 <ehird> ({ ... }) also introduces a new variable scope, I believe.
18:22:23 <ehird> Which is why I used it: to avoid _spawned_proc name-clashing with a later use of SPAWN.
18:22:28 <AnMaster> ehird, since I do intend to be reasonably portable I used the extensions that could easily be optional (__attribute__ for error checking mostly) and avoided the other stuff
18:22:48 <ehird> What program are you writing? And will you use my implementation of Plan 9's threading model if I write it? :P
18:22:51 <AnMaster> ehird, wait, does that nest a function inside another?
18:23:07 <ehird> GNU C lets you do that, too.
18:23:21 <ehird> No. It doesn't. It's a feature.
18:23:30 <AnMaster> ehird, with a non-executable stack it does iirc
18:23:33 <ehird> http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html
18:24:00 <AnMaster> ehird, it uses a trampoline and what not
18:24:06 <ehird> Yes. http://gcc.gnu.org/onlinedocs/gccint/Trampolines.html
18:24:13 <ehird> "normally resides on the stack"
18:24:15 <ehird> Keyword normaally.
18:24:24 <AnMaster> ah they added support for it to be elsewhere?
18:24:43 <ehird> The operating system may also require the stack to be made executable before calling the trampoline. To implement this requirement, define the following macro.
18:24:43 <ehird> — Macro: ENABLE_EXECUTE_STACK
18:24:44 <ehird> Define this macro if certain operations must be performed before executing code located on the stack. The macro should expand to a series of C file-scope constructs (e.g. functions) and provide a unique entry point named __enable_execute_stack. The target is responsible for emitting calls to the entry point in the code, for example from the TARGET_TRAMPOLINE_INIT hook.
18:27:00 <ehird> "Do not attempt to disprove the four-colour theorem on your flag!"
18:27:02 <ehird> — http://www.otago.ac.nz/philosophy/Staff/JoshParsons/flags/ratings-c.html
18:27:38 <AnMaster> ehird, issues with executable stack exists. There are a few
18:27:48 <ehird> Nobody uses OpenBSD.
18:28:07 <AnMaster> ehird, executable stack makes baby Bruce Schneier cry
18:29:18 <AnMaster> ehird, also I do see uses for executable stack. Just that I think it makes more sense to put it elsewhere. Somewhere away from those char buf[MAXBUF]; and such
18:32:07 <ehird> Common Lisp's type system is weird.
18:33:28 -!- soupdragon has quit ("Leaving").
18:34:20 <ehird> The symbol (atom, if you're not familiar with the terminology) T is a symbol. It is also a boolean, meaning "true". Every value in Common Lisp is of the type T — not a different thing to the symbol T sharing the same name, but an actual symbol being used as a type. It is the superclass, so to speak, of every other type.
18:34:23 -!- Sgeo has joined.
18:35:04 <ehird> NIL is: a symbol; a list (the terminator of a list, to be precise); a null.
18:35:24 <ehird> However, NIL is not of type NIL.
18:35:41 <ehird> A symbol; a list (the terminator of a list, to be precise); a null.
18:35:55 <ehird> (type-of nil) is NULL, so null is its "main" type.
18:35:58 <AnMaster> ehird, as for it being a list and a null, makes as much sense as 0 being 0 and NULL in C (sure it might have another value)
18:36:21 <ehird> But it's strange how T is a type as well as a value, and they're the same thing.
18:36:32 <ehird> And everything else is of type T, too.
18:36:39 <ehird> [18:33] ehird: The symbol (atom, if you're not familiar with the terminology) T is a symbol. It is also a boolean, meaning "true". Every value in Common Lisp is of the type T — not a different thing to the symbol T sharing the same name, but an actual symbol being used as a type. It is the superclass, so to speak, of every other type.
18:36:48 <ehird> That was TWO LINES above "NIL is:".
18:37:01 <AnMaster> couldn't* see at this distance
18:37:08 <AnMaster> I'm holding a boot in front of me
18:37:21 * AnMaster is both chatting on irc and writing a report
18:37:46 <AnMaster> ehird, and the monitor with irc is pushed back, to make room for laptop in front
18:38:23 <AnMaster> ehird, I need a bit of help with an English term
18:38:48 <AnMaster> ehird, what do you call it when a DB becomes inconsistent, Not as in corrupted db file but as in "oops, forgot the foreign key"
18:39:00 <AnMaster> I know the Swedish word for it, but I can't find the English term
18:39:43 <AnMaster> ehird, doesn't that refer to a database file sort of level
18:39:55 <ehird> I'm not a relational DB person, sorry.
18:40:00 <ehird> I try and avoid them wherever possible.
18:40:32 <AnMaster> Deewiant, meh now it slipped my mind X|
18:41:12 <AnMaster> brott mot databasintegritet. not quite...
18:43:55 * AnMaster decides to formulate it another way
18:44:03 <AnMaster> err that is a Swedishism probably
18:53:15 -!- FireyFly has joined.
18:55:53 -!- FireyFly has changed nick to FireFly.
19:52:47 -!- sebbu2 has joined.
19:59:02 -!- sebbu has quit (Read error: 60 (Operation timed out)).
20:06:38 -!- jpc has joined.
20:12:47 <AnMaster> so why does my konsole window say "xterm" in the title bar...
20:13:23 <oerjan> it's been taken over by daleks
20:17:19 -!- poiuy_qwert has quit ("Leaving").
20:20:57 -!- Warriphone has quit (Read error: 110 (Connection timed out)).
20:26:00 <AnMaster> oerjan, ... I never seen Dr Who, so while I know what it references I don't know why
20:26:37 <oerjan> but hint: EX-TERM-IN-ATE
20:26:46 -!- BeholdMyGlory has quit (Read error: 104 (Connection reset by peer)).
20:26:56 -!- augur has joined.
20:37:30 <ehird> oerjan: xterm-inate xD
20:37:55 <pikhq> AnMaster: Watch Doctor Who.
20:37:55 * ehird completes the final piece minus one of his org-mode blogging horrific hack^W^Wsystem
20:38:07 <ehird> No, it's functional!
20:40:28 <ehird> who would have guessed that an outliner could export to html with syntax highlighting of any language, embedded latex, and rendered diagrams?
20:40:28 <ehird> anyone who knew that it was an emacs mode, that's who.
20:41:56 <pikhq> Emacs: it does everything.
20:43:11 <ehird> say, there's an elisp thingy that implements the common xml-rpc blogging api, isn't there?
20:43:21 <ehird> i could plug that into this and get a complete in-emacs blogging system XD
20:54:30 -!- BeholdMyGlory has joined.
21:02:31 <ehird> #+begin_src literate-haskell
21:02:32 <ehird> > main = putStrLn "Hello, world!"
21:02:32 <ehird> This actually syntax highlights when exported to HTML or LaTeX, and it works for ANY language Emacs can highlight.
21:02:48 <ehird> org-mode is sweeeeeet.
21:04:03 <pikhq> ehird: That's beautiful.
21:14:32 <Deewiant> And what kind of HTML does it generate?
21:15:38 <ehird> Deewiant: Define "what kind".
21:16:00 <Deewiant> How does it implement the syntax highlighting
21:16:31 <ehird> Either <span>s with color:s, or you can get it to generate a big ol' hunk of CSS for every syntax possibility; that's 12k, but you can use a css compression tool to get it down to 3k.
21:17:32 <Deewiant> It can't generate a hunk only for the ones used? (Assuming that would save practically any space)
21:17:49 <ehird> Deewiant: I lied; that stylesheet is just some org-mode stylesheet.
21:17:55 <ehird> It seems that yes, it does only generate the ones used.
21:19:08 <ehird> I tell another lie: that CSS does include the syntax highlighting.
21:19:22 <ehird> It seems that it can highlight org-mode code, and dired output. XD
21:20:10 <ehird> Hey, it does work with *every font-lock mode in Emacs*.
21:21:14 <ehird> Personally, I'm just going to leave it generating inline colours.
21:21:30 <ehird> It's not like Blogger's added markup isn't spewtastic anyway.
21:22:01 <AnMaster> <ehird> i could plug that into this and get a complete in-emacs blogging system XD <-- pretty sure I read about that somewhere already
21:22:29 <ehird> Yes, people use org-mode for blogging and also the XML-RPC stuff.
21:22:38 <ehird> But I don't know if they're combined so that I could do M-x publish-org-blog-post.
21:23:37 <AnMaster> ehird, that was what I meant I read about iirc
21:24:42 <AnMaster> <ehird> It's not like Blogger's added markup isn't spewtastic anyway. <-- who is "Blogger" with a capital B ;P
21:24:51 <ehird> http://www.blogger.com/
21:25:15 <ehird> Now-Google's-ex-Pyra's ye internette cornerstone blogging system.
21:25:30 <AnMaster> oh right. I have it mentally filed as "the orange/white squiggle icon blog site"
21:25:46 <ehird> That squiggle is also known as "B".
21:26:32 <AnMaster> ehird, I thought it was a child drawing of a boat
21:27:14 <oerjan> blog, blog, blog your, er
21:27:24 <ehird> Sweet, org-mode lets me use TeX style ^ and _ in plain html.
21:27:38 <ehird> That's nice for when the actual LaTeX embedding is too much.
21:27:46 <AnMaster> ehird, "blog, blog blog your blog!
21:28:23 <oerjan> feels inelegant. spammy, even.
21:28:39 <ehird> blog, blog, blog your spam
21:28:47 <ehird> gently down the tubes
21:28:54 <fizzie> I had to spend a while looking for how to disable that feature in org-mode, because it kept messing up the _-rich filenames in html export.
21:28:54 <ehird> marry me marry me marry me marry me
21:28:56 <ehird> russian brides for cheap
21:29:16 <ehird> fizzie: ^:{} or ^:nil
21:29:19 <AnMaster> "Both beg and end are both pointer expressions." <-- GCC manual. Approved by The redundantly Redundant Committee for Redundancy
21:29:22 <ehird> former for just allowing foo_{bar} etc
21:30:10 <ehird> pri: turn on/off priority cookies
21:30:18 <ehird> omg org-mode does footnotes
21:30:55 <ehird> my life is complete
21:30:56 <fizzie> ehird: Yes, I know that *now*.
21:30:59 <AnMaster> ehird, at the end of the document? Rather than the end of the page
21:31:04 <AnMaster> and aren't those called end notes
21:31:11 <ehird> AnMaster: They're footnotes.
21:31:33 <AnMaster> ehird, also that latex. Does it render equations to unicode, or to images?
21:31:55 <fizzie> Apparently I did "#+OPTIONS: num:nil ^:nil" but now I don't remember what num:nil does.
21:32:07 <AnMaster> ehird, how is wikipedia's latex implemented?
21:32:10 <ehird> If you want Unicode you can just do latex:nil and use jsMath instead.
21:32:25 <ehird> AnMaster: Images, or a very basic →html thingy that only works for a very small subset.
21:32:30 <ehird> Or →mathml which does I don't know.
21:32:38 <ehird> fizzie: Disables TOC numbers in headings
21:33:08 <AnMaster> ehird, does it only do latex equations, or the full thing
21:33:19 <ehird> "In particular, note that you can place commonly-used (export) options in a separate file which can be included using #+SETUPFILE."
21:33:25 <ehird> AnMaster: Equations.
21:33:38 <pikhq> ehird: I've never gotten the ->mathml thing to work.
21:33:47 <AnMaster> ehird, I was looking forward to pstricks in html :(
21:36:01 <ehird> #+OPTIONS: toc:nil num:nil author:nil creator:nil timestamp:nil
21:36:14 <ehird> ↑ aka "No, I don't want any of that crap" mode
21:36:28 <fizzie> Are you also going to use MobileOrg on your iDevice?
21:36:41 <ehird> That would be impractical for writing blog posts on!
21:36:57 <ehird> And I don't need todo lists; I never forget to do things.
21:37:11 <ehird> Or at least, I never remember that I've forgotten to do something.
21:37:18 <ehird> Which, if you don't really have any worldly responsibilities, is the same thing.
21:38:21 <oerjan> that sounds reassuring :D
21:40:21 <ehird> #(...) is a vector in elisp right?
21:40:25 <ehird> How do you access the first elem?
21:41:54 <ehird> Ugh, one part of this whole ordeal is going to be a pain.
21:42:11 <ehird> Using mmm-mode so that stuff inside #+begin_src LANG ... #+end_src is displayed with that mode.
21:42:30 <ehird> That way, I can edit blog posts as Literate Haskell with all the haskell-mode conveniences while still using org-mode outside.
21:52:10 <augur> ehird, how did your semantics discussion earlier go?
21:52:25 <ehird> which discussion in particular
21:52:31 <augur> the one with soupdragon
21:53:11 <augur> the one i was participating in before having to get on my flight
21:53:36 <ehird> define "go"; I pretty much told him that I thought he should handle things like AND (LOVES JOHN) (LOVES MARY) by the rule: if there is a function that, given enough arguments, produces a value of type T, and this function is in a place where we need a type T, make the whole expression a function with its arguments
21:54:10 <ehird> that produces (\x -> (\y -> AND (LOVES JOHN x) (LOVES MARY y))) but I guess with an amendment "if there are two such expressions and they take the same type, combine their arguments" it would work
21:54:49 <augur> given some functions f, g :: a -> Bool
21:55:05 <augur> you can combine them to get \x -> f(x) & g(x)
21:55:19 <augur> no? but you said combine their arguments D:
21:56:11 <ehird> rewrite (f ...(expr::a->b->...->T)...)
21:56:11 <ehird> to (\a,b,... -> f ...(expr's function body)...)
21:56:38 <ehird> if there are multiple such occurrences of this in the same expression, take all the argument types they share and combine them into a single argument
21:57:03 <ehird> so AND (LOVES JOHN) (LOVES MARY) becomes (\x -> AND (LOVES JOHN x) (LOVES MARY x)), not (\x -> (\y -> AND (LOVES JOHN x) (LOVES MARY y)))
21:57:11 <oerjan> john loves mary and mary john </ducks>
21:57:21 <ehird> john loves marrying mary
21:57:30 <augur> well it sounds like you've discovered cojunctivism to some degree
21:58:44 <ehird> http://emacspeak.googlecode.com/svn/trunk/lisp/g-client/gblogger.el
21:58:52 <ehird> i'll be blahhging the intertubes in no time w/ this
21:59:12 <ehird> diabeetus blahhging
21:59:58 <ehird> i'm personally just amazed i managed to coerce blogger into outputting something...nice
22:00:13 <ehird> i was not of the awareness of the possibility of this.
22:01:42 <augur> ehird, i was thinking about the graphics engine thing
22:01:42 <ehird> hey i just realised http://emacspeak.googlecode.com/svn/trunk/lisp/g-client/gblogger.el was written by the blind guy who makes emacsspeak :)
22:02:19 <augur> and im really interested in this constraint stuff, im just not sure if i understand precisely what it would mean
22:03:52 <ehird> augur: well it's basically like prolog
22:03:57 <ehird> you give prolog a bunch of constraints on values
22:04:00 <ehird> and it outputs all the possibilities
22:04:08 <ehird> it's the same for a layout engine, where the values are things like
22:04:16 <ehird> coords of bottom of foo
22:04:20 <ehird> and the engine is less... well, TC
22:04:30 <ehird> plus, it picks one single possibility via some metric for picking the best layout
22:04:34 <ehird> tightest packed, or whatever
22:04:42 <augur> im just trying to imagine how the syntax then expresses these constraints
22:04:58 <ehird> well it's just an abstract data structure
22:05:24 <augur> i mean in the language being designed
22:05:47 <augur> how is, say, "a square 50 px on a size" expressed
22:07:56 <augur> less say, filled with red
22:11:15 <ehird> augur: i meant in the language being designed too
22:11:23 <ehird> the constraint engine is an internal thing, mostly it's exposed via user defined functions
22:11:29 <ehird> like, you know, square(). :P
22:13:08 <augur> ok, and what does the constraint for such a square look like
22:14:08 <augur> the square 50px on a side with red fill!
22:15:36 <augur> i just want to know what the constraint looks like, in some sense
22:16:30 <augur> Square [Fill Red] 50px
22:17:35 <augur> for ... data Shape = Square [Attribute] Size | ...; data Attribute = Fill Color | Stroke Color | ...
22:22:24 <ehird> you're thinking about this all wrong.
22:22:36 <ehird> constraints, not objects
22:22:43 <augur> yes, but what DEFINES the constraint
22:22:57 <ehird> your question does not make sense.
22:23:08 <augur> the constraint-solver has to look at these constraints, right?
22:23:19 <augur> so what does it see when it looks at them
22:23:41 <augur> i mean, is square(50px) the constraint itself
22:23:50 <augur> or is that just some magic function that constructs the constraint in the background
22:23:52 <ehird> The constraint data structure is something like this:
22:23:56 -!- anmaster_l has quit (Read error: 110 (Connection timed out)).
22:24:24 <ehird> { x = Square, side x == 50px, (dunno about the fill stuff) }
22:24:39 <ehird> Square itself desugars to more constraints
22:24:51 <ehird> my machine is overheating
22:25:17 <augur> i see what you're going for
22:25:20 <ehird> i can't tell if it is
22:25:32 -!- ehird has quit.
22:27:29 <augur> maybe he restarted out of caution
22:29:42 -!- ehird has joined.
22:29:57 <ehird> my fans just spun up to full, you see
22:29:59 <ehird> they occasionally do that
22:30:05 <ehird> worrying but seemingly just a glitch
22:30:11 <ehird> but it's noisy and i don't want to take any chances
22:30:17 <augur> do you have iState menus?
22:30:30 <SimonRC> does top give you anything useful?
22:30:34 <ehird> i'm a minimalist. things like that are mere distractions to me
22:30:37 <ehird> SimonRC: too late, i rebooted
22:30:41 <ehird> but activity monitor said cpu was like 1%
22:30:47 <ehird> so clearly not cpu load
22:30:50 <ehird> perhaps a heatsink issue
22:30:55 <augur> well, iStat menus has a temp indicator
22:30:58 <ehird> or, as i suspect, a fan control issue
22:31:34 <SimonRC> well, my laptop liked to do jet impressions when suspending
22:31:39 <augur> i like the idea, im just not sure if its absolutely necessary, ehird. ill consider it.
22:32:04 <SimonRC> however, last time I suspended it it decided to power off the external USB HD...
22:32:09 <ehird> everyone should preemptively add http://ehird.blogspot.com/ to their feed readers because i am awesome
22:32:32 <SimonRC> which is reasonable except the kernel knows damn well that / is on that HD, so unsuspend kinda didn't happen
22:33:02 <oerjan> that blog will be the new revolution! or possibly, just revolting.
22:33:46 <augur> ehird: if you start posting interesting things, ill totally link you on my blog
22:34:12 <ehird> augur: like does type system hackery, programming language and OS musings count as interesting?????
22:34:18 <ehird> or just BORING ASS LINGUISTICS
22:34:25 <augur> ehird, no thats totally interesting
22:34:33 <augur> my blog isnt all linguistics you know
22:34:39 <ehird> ps you should totally dig my minimalist design because it is RAD and i spent five years fighting against blogger to makek it work
22:36:03 <augur> http://www.wellnowwhat.net/blog/?p=353 << see? not linguisticy!
22:36:16 <augur> my next series of posts is going to be on this thing we're discussing
22:36:28 <augur> and then one on building a simple prolog-ish engine
22:36:33 <ehird> "I’ve got a need for a product of this sort. Please send me an email because I’d love to talk about it."
22:36:37 <ehird> blog comments are so crappy
22:36:51 <ehird> "Hey you posted an interesting post about stuff! I NEED YOU TO CODE THIS EMAIL ME"
22:37:22 <augur> i figured i'd leave that one tho because he was sincere. i emailed him and he seemed to be interested in more complex knowledge engines and i said i wasnt familiar with any of them
22:37:50 <ehird> the gblogger functions are oriented around interactive use and this makes me sad
22:38:07 <ehird> emacs Blogger interface
22:38:42 <ehird> i'm trying to wire up org-mode (an outliner/markup/diagram-renderer/LaTeX-embedder/syntax-highlighter/you name it) to gblogger
22:38:57 <ehird> so as to be able to write an org file, run an emacs command, and have it appear on http://ehird.blogspot.com/
22:39:08 <ehird> and thus never have to interact with blogspot's rubbish admin ui!
22:40:33 <augur> ehird, ive decided on some basic functions
22:40:42 <augur> for the graphics engine
22:41:25 <augur> namly, below[left|right|center|just|nothing] ...
22:41:46 <augur> beside[top|middle|bottom|just|nothing] ...
22:42:14 <augur> pad[t r b l | tr bl | trbl] X
22:42:23 <ehird> i don't get your syntax
22:42:40 <augur> brackets enclose options
22:43:04 <augur> e.g. below[left] A B means "put B below A, and align them left"
22:43:22 <augur> below ... == below[] ... == below[center] ...
22:43:23 <ehird> struct Left :: BelowOpt; struct Right :: BelowOpt
22:43:37 <augur> sure, whatever you want
22:43:53 <ehird> below :: [BelowOpt] -> [Drawable] -> Below
22:44:06 <ehird> below[][a,b,c] == below[center][a,b,c] (that [] is a bit ugly tho)
22:44:15 <ehird> (the below[][...] thing)
22:44:24 <augur> well, i dont know what the options syntax should be
22:44:30 <augur> i wanted to avoid {}
22:44:30 * ehird decides to leave the postiing automation for later
22:44:51 <ehird> augur: ah! we can build optional arguments into the language
22:45:02 <ehird> no need to have actual options like i said, a list of a data structure works for them
22:45:06 <ehird> all we need is optional arguments
22:45:20 <ehird> {} is the punctuation i haven't used yet so sorry but I'm gonna take it :D
22:45:34 <augur> im not sure what you mean
22:45:39 <augur> example of what you have in mind?
22:45:55 <ehird> below :: ({BelowOpt}, List Drawable) -> Below
22:45:58 <ehird> in the definition:
22:46:15 <ehird> below(opts{Center}, things) = ...
22:46:19 <ehird> (Center is the default)
22:46:31 <ehird> I wrote that slightly wrong
22:46:37 <augur> below {align => left} [a,b,c]
22:46:38 <ehird> below :: {BelowOpt} -> List Drawable -> Below
22:46:51 <ehird> below{opts=Center}(things) = ...
22:46:58 <ehird> augur: in the BelowOpt group, have
22:47:06 <ehird> struct Align :: Direction -> BelowOpt
22:47:16 <augur> def below(ops = { :align => :center }, items)
22:47:17 <ehird> below{Align Left}[a,b,c]
22:47:30 <ehird> can you have multiple opts in this case
22:47:50 <augur> for instance, you'd have another option space
22:48:01 <augur> which specifies the separation between the items when belowing them
22:48:05 <ehird> below :: {[BelowOpt]} -> List Drawable -> Below
22:48:06 <ehird> below{opts=[Align Center]}(things) = ...
22:48:12 <ehird> below{Align Left, Poop Blah}[a,b,c]
22:48:30 <ehird> basically, {...} means optional argument; if you omit it in a call, it just assumes the default value
22:48:36 <ehird> and {a,b} desugars to {[a,b]}
22:48:38 <ehird> for convenient options
22:48:52 <augur> \below{align=left,space=5px}{a}{b}{c}
22:49:25 <ehird> i would argue that latex has pretty nice syntax :P
22:49:41 <augur> {} should never enclose args, in my opinion
22:49:50 <ehird> well it's not enclosing anything else in my syntax
22:50:11 <augur> i prever a haskellish syntax
22:50:23 -!- jpc has quit ("I will do freaking anything for a new router.").
22:50:56 -!- jpc has joined.
22:50:58 <pikhq> What ehird's been discussing is essentially Haskell + default arguments.
22:51:07 <pikhq> (... Well, because he's not mentioned the other divergences from Haskell)
22:51:14 <augur> but haskell doesnt allow arbitrary args
22:51:20 <augur> i really want it to just look like
22:51:31 <pikhq> ... Whereas what he's discussing does.
22:52:01 <augur> i can sort of accept the list tho. thats fine.
22:52:13 <ehird> augur: well we could do the obvious thing
22:52:15 <augur> what is {} denoting for you, ehird?
22:52:16 <ehird> and introduce map syntax
22:52:22 <ehird> augur: {} = optional argument
22:52:26 <pikhq> augur: So, is that passing default arguments to the function or arguments to the result of the function?
22:52:28 <ehird> map syntax would be just
22:52:40 <ehird> but we still use data structures
22:52:52 <ehird> below { Align: Left } [a,b,c]
22:53:29 <augur> pikhq: f ... is sugar for f[] ..., and f defaults on its respective options
22:53:40 <augur> ok so {} is a hash then
22:53:47 <pikhq> foo :: {a} -> b -> (a->b) -> (a->c)
22:53:48 <ehird> but that has issues
22:53:54 <pikhq> Hey, look, it's ambiguity!
22:53:54 <ehird> it means you can do { Align: 3 }
22:54:16 <ehird> foo aB :: (a->b)->(a->c)
22:54:17 <pikhq> ehird: ... As you do it, yes.
22:54:23 <ehird> foo anA :: b->(a->b)->(a->c)
22:54:35 <augur> beside[left] a b c looks best to me
22:54:49 <ehird> augur: i don't think this needs to be a heavyweight language, so just go syntax made
22:54:54 <pikhq> ehird: Except that the function is polymorphic.
22:54:54 <ehird> make it convenient
22:55:06 <ehird> pikhq: yes, and? you know by the time you get a function argument
22:55:20 <ehird> you specify optional args with {}
22:55:21 <augur> the other function i was considering was over
22:55:26 <ehird> foo x is always using the default
22:55:30 <ehird> foo {x} is always overriding it
22:55:31 <augur> if A is a triangle, and B is a circle
22:55:32 <pikhq> ehird: That's what disambiguates it.
22:55:59 <augur> over A B is the image with the circle positioned above the triangle, both conconcentric
22:56:20 <ehird> http://ehird.blogspot.com/2010/01/hello-world.html
22:56:20 <ehird> iiiiiiiiii posted this with org-mode
22:56:28 <augur> and you could have params that specify which points are con-ed
22:56:34 <augur> e.g. over A B == over[center] A B
22:56:43 <ehird> todo: make one css tweak, that funky mmm-mode thing, automate the actual posting
22:56:44 <augur> but you could do over[topleft] A B
22:56:52 <augur> which is where A.topleft == B.topleft
22:57:05 <augur> or you could do over[x y] A B
22:57:12 <pikhq> foo bar -- Has two valid types. b->(a->b)->(a->c) and (a->b)->(a->c). In the first, a is the same type as bar, and in the second, b is the same type as bar.
22:57:18 <augur> which is equivalent to over[bottomleft x y]
22:57:39 <pikhq> (if you don't do the "wrap default args in brackets" bit)
22:57:55 <augur> where B.bottomleft = A.bottomleft + <x,y>
22:59:55 <augur> as it turns out, over[topleft A.width 0] A B produces the same image as beside A B
23:00:13 <augur> which suggests that over should be the function that beside and below are defined in terms of
23:03:37 <ehird> http://ehird.blogspot.com/2010/01/hello-world.html
23:03:38 <ehird> someone leave a message of complete admiration for me kthxbai
23:03:49 <augur> doing this in terms of actual objects, tho, ehird, seems to be relatively simple
23:03:58 <ehird> pikhq: have you used literate-haskell-mode?
23:04:17 <ehird> augur: To hell with objects! Long live data structures!
23:04:31 <pikhq> ehird: No, should I?
23:04:32 <augur> ehird: well, data structures, whatever. same thing to me.
23:04:51 <pikhq> augur: They're quite different in concept.
23:04:52 <Sgeo> http://www.youtube.com/watch?v=YiYBRgsxQUc
23:04:53 <ehird> pikhq: nope, just wondering how to have mah bird tracks auto-added
23:05:00 <augur> if A is some data structure consisting of paths, basically
23:05:14 <augur> what you'd have is two parts to it
23:05:36 <augur> where Path has points in the range [0,1]
23:06:02 <pikhq> An object is a thing that possesses members and methods. These can be public and private. An object can inherit its methods and members from another object, and override them.
23:06:16 <pikhq> A data structure is a thing that contains things.
23:06:35 <augur> scale p (Shape (w,h) s) = Shape (p*w, p*h) s
23:07:07 <pikhq> That an object can be used for data structures is merely an interesting property.
23:07:27 <augur> scale (wp,hp) (Shape (w,h) s) = Shape (wp*w, hp*h) s
23:08:05 <pikhq> To ram the point in further: compare C structs and C++ classes.
23:08:13 <augur> actually, it'd be more, data Shape Shape AffMatrix Path
23:10:53 <augur> and then when you draw this, all you do is apply the affine transform matrix to the path points to calculate the actual look of the shape, and stroke/fill
23:12:04 <ehird> http://ehird.blogspot.com/2010/01/hello-world.html
23:12:04 <ehird> BEHOLD THE SYNTACTICALLY HIGHLIGHTED CODE
23:12:29 <augur> ehird, i tried to comment as anonymous but it gave me an error
23:12:53 <augur> /!\ Your request could not be processed. Please try again.
23:13:16 <ehird> It supports Google accounts and OpenIDs, if those are okay for you.
23:14:15 <ehird> Perhaps name/URL will work?
23:14:20 <ehird> augur: Also, perhaps some sort of spam filter got you.
23:16:51 <augur> maybe it was too short
23:17:10 <augur> "Posted by Anonymous on January 05, 2010."
23:17:30 <augur> shouldnt we be going to jupiter? :|
23:17:39 <pikhq> Why yes, it's been 2010 for 5 days now.
23:17:42 <ehird> i think we make contact this year or something
23:17:46 <ehird> i saw it in a documenntary
23:17:53 <ehird> those movies are all documentaries right
23:18:13 <oerjan> yes, according to many-world's interpretation
23:18:24 <Sgeo> Well, at least we don't have that alliance with the Aschen trying to sterilize Earth
23:20:30 <augur> all we wanna do is explore the galaxy and fuck green chicks/dudes
23:20:35 <augur> is that such a crime?
23:20:49 <oerjan> i hear blue is all the rage these days
23:20:54 <pikhq> Only if you're not Kirk.
23:21:07 <augur> pikhq: but we all want to be kirk so its cool right
23:21:12 <pikhq> Not-Kirks have to content themselves with other colors.
23:21:45 <pikhq> augur: That's why the punishment for the crime is exploring the galaxy and fucking green chicks.
23:22:48 <ehird> so the punishment is, essentially, that you cannot be gay?
23:23:03 <augur> oh i see what he means
23:23:09 <augur> the punishment is fucking people you dont want to fuck
23:23:13 <pikhq> Cruelest thing ever.
23:23:22 <ehird> EVEN FOR STRAIGHT PEOPLE
23:23:32 <ehird> Cue T-Rex: "I feel like a possibility has been taken away from me that I never knew I had!"
23:23:36 <ehird> "This is OPPRESSION!!"
23:23:44 <pikhq> ehird: Nobody's straight. Don't you ever read ship fanfiction?
23:24:00 <augur> ehird, tell me if this makes sense
23:25:34 <augur> if you rotate a shape by some angle, after rotating, the rotated shape is fit so that its bounding rect is always the unit square, and the resulting things size is smaller than the initial things size
23:25:39 * ehird ponders on a topic for his first opst
23:25:42 <augur> whichever it turns out to be
23:26:46 <augur> e.g. if you rotate a 1x1 square you get back a 1x1 diamond, with its points at the <0,0.5>, <0.5,0>, <1,0.5>, <0.5,1>
23:27:32 <augur> and its size reduced from, lets say, 10x10 as a square, to 5root2 x 5root2 as a diamond
23:27:43 -!- dbc has quit (Read error: 60 (Operation timed out)).
23:27:43 <augur> sorry, 10root2 x 10root2
23:28:14 <augur> (rotating by 45* obviously)
23:29:31 <ehird> My first post will be "Computing fib(3!) in Haskell's type system", which is really about type families being cool and such.
23:29:33 <augur> does that make sense? or should shapes exist in a full euclidean plane? because that i think would ruin the use of things like beside()
23:29:53 <augur> elliot! types are not for computing! :|
23:30:00 <augur> you're a bad bad boy
23:31:07 <SimonRC> stop hangin' 'round with that dons kid; he's neva' up to no good!
23:44:12 <pikhq> ehird: Mmm, undecidable instances...
23:45:53 -!- dbc has joined.
23:58:34 <ehird> http://ehird.blogspot.com/2010/01/computing-fib3-in-haskells-type-system.html
23:59:59 <pikhq> ehird: BTW, GHC Haskell has a TC type system.