←2007-11-23 2007-11-24 2007-11-25→ ↑2007 ↑all
00:06:26 -!- Alvin^ has quit (Read error: 110 (Connection timed out)).
00:23:07 -!- bsmnt_bot has quit (kubrick.freenode.net irc.freenode.net).
00:23:18 -!- wolfy has joined.
00:24:12 -!- bsmnt_bot has joined.
00:33:10 -!- ehird` has quit (Remote closed the connection).
00:41:10 -!- wolfy has quit (Remote closed the connection).
01:40:51 -!- immibis has joined.
01:53:16 -!- immibis has quit ("Hi Im a qit msg virus. Pls rplce ur old qit msg wit tis 1 & hlp me tk ovr th wrld of IRC. OUCH!!!").
02:33:19 -!- Slereah has joined.
03:02:52 -!- Slereah- has quit (Read error: 110 (Connection timed out)).
04:57:16 -!- puzzlet_ has quit (Remote closed the connection).
04:57:17 -!- puzzlet has joined.
05:02:33 -!- puzzlet_ has joined.
05:08:30 -!- puzzlet__ has joined.
05:13:46 -!- puzzlet_1 has joined.
05:14:32 -!- puzzlet has quit (Connection timed out).
05:20:16 -!- Sgeo has quit (Connection timed out).
05:20:50 -!- puzzlet has joined.
05:23:01 -!- puzzlet_ has quit (Connection timed out).
05:25:06 -!- puzzlet_1 has quit (Read error: 104 (Connection reset by peer)).
05:26:00 -!- puzzlet__ has quit (Read error: 110 (Connection timed out)).
05:26:16 -!- puzzlet_ has joined.
05:32:15 -!- puzzlet__ has joined.
05:39:10 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
05:44:00 -!- puzzlet_ has quit (Read error: 110 (Connection timed out)).
05:58:31 -!- puzzlet__ has quit (Remote closed the connection).
05:58:33 -!- puzzlet has joined.
06:21:09 -!- immibis has joined.
06:22:11 * immibis was asked by google "Did you mean: Interfering with wikipedia?"
06:27:48 <oerjan> o_O
06:28:55 * immibis searched for "interfacing with wikipedia"
06:29:13 <oerjan> ic
06:31:05 <pikhq> まちがった、ね。
06:32:09 * immibis 's client does not display characters as UTF-8
06:32:30 * oklopol needs to learn some japans
06:32:42 * oerjan almost assumed pikhq was being confused, with all those question marks
06:33:01 <immibis> oerjan: it was a string of characters encoded as UTF-8
06:33:10 <immibis> oklopol: there's only one japan
06:33:11 <oerjan> i know that
06:33:27 <oerjan> but sometimes i forget
06:33:46 * immibis is annoyed that the creator of rubicon won't release its source code
06:47:15 * pikhq declares that the lack of source code denies it from being an esolang
06:48:03 <pikhq> Oh, RUBE is the esolang.
06:48:31 <pikhq> Which just means that I should go bow before my shrine to cpressy for a bit.
06:48:50 <oerjan> picture!
06:49:23 <pikhq> It's nonexistent.
06:49:27 <pikhq> Although I should make one.
06:49:38 * pikhq gets the Befunge source code printed out
06:54:46 <pikhq> I intend to sleep. This is an unregulated action.
06:54:51 <pikhq> I cause the AFO to do the same.
07:06:13 -!- puzzlet has quit (Remote closed the connection).
07:06:14 -!- puzzlet_ has joined.
07:10:23 <bsmntbombdood> weeeeeeeel
07:10:42 <bsmntbombdood> SUP BITCHES
07:16:17 -!- puzzlet_ has quit (Remote closed the connection).
07:16:19 -!- puzzlet has joined.
07:26:36 -!- puzzlet_ has joined.
07:33:33 -!- puzzlet has quit (Connection timed out).
07:38:24 * immibis 's browser tried to display a backup as a webpage.
07:42:24 <immibis> [20:42] ->> #esoteric :No such nick/channel
07:42:54 <oerjan> LIES
07:43:00 <immibis> no not a lie
07:43:08 <immibis> i said /invite #esoteric #hadjin
07:43:20 <immibis> so the server said #esoteric: No such nick/channel
07:44:07 <oerjan> sounds like a lie to me
07:45:30 <bsmntbombdood> no one could vote for kucinich!
07:45:34 <bsmntbombdood> his wife is too hot!
07:46:08 <immibis> oerjan: /invite #something #something_else
07:53:11 <oerjan> hm... why is there about a _page_ of invites to #hadjin in my status window...
07:54:37 <immibis> because i wanted to find out how long it would take you to notice?
07:55:36 <oerjan> nah, even you cannot be _that_ annoying *ducks*
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:06:30 -!- immibis has quit (Remote closed the connection).
08:14:33 -!- asiekierka has joined.
08:16:04 -!- oerjan has quit ("Good night").
08:43:47 -!- jix has joined.
10:05:26 -!- puzzlet_ has quit (Remote closed the connection).
10:05:27 -!- puzzlet has joined.
10:18:04 -!- puzzlet has quit (Remote closed the connection).
10:26:18 -!- puzzlet has joined.
11:24:57 -!- SEO_DUDE has quit (Remote closed the connection).
11:41:55 -!- jix has quit (Nick collision from services.).
11:42:05 -!- jix has joined.
12:14:07 -!- SEO_DUDE has joined.
12:18:43 -!- puzzlet has quit (Remote closed the connection).
12:18:44 -!- puzzlet_ has joined.
13:33:20 -!- SEO_DUDE has quit (Remote closed the connection).
13:47:03 -!- SEO_DUDE has joined.
14:49:14 -!- ehird` has joined.
14:54:09 <asiekierka> osht
14:54:11 <asiekierka> not ehird`
14:54:19 <ehird`> rolleyes
14:54:25 <ehird`> i'm here every day, in case you didn't notice
15:57:52 <asiekierka> But you hate me.
16:19:44 -!- Figs4 has joined.
16:20:15 -!- Figs4 has changed nick to Figs.
16:20:44 <Figs> Hello
16:21:14 <Slereah> Hello3
16:21:40 <Figs> Is "multiple dispatch" really any different than overloading on C-style functions?
16:21:57 <Figs> (ie, not owned by an object)
16:22:23 <Figs> or am I missing the concept? :P
16:22:30 <Figs> {I assume I am}
16:23:47 <Figs> Oh... I think I see it
16:24:12 <ehird`> You are missing the concept
16:24:15 <ehird`> :)
16:24:43 <Figs> yeah, I think I just got it
16:26:16 <Figs> if I have a collide(collidable x, collidable y) where collidable is abstract... then in Java/C++-like languages it won't actually go ahead and automatically call say collide(spaceship x,asteroid y)...
16:26:54 <Figs> that's the difference, right?
16:27:27 <Figs> (or as nearly as I can explain it in my crappy thought->writing attempt)
16:27:44 <ehird`> um, kind of
16:27:46 <Figs> yay for mangled language terms :D
16:27:47 <ehird`> wikipedia :P
16:27:53 <Figs> wikipedia confused me :P
16:28:03 <Figs> but I think I got it
16:28:06 <Figs> now
16:28:07 <Figs> :P
16:28:39 <Figs> yay.
16:28:41 <Figs> ok
16:28:55 <Figs> I've been thinking about a lot of weird shit this morning.
16:29:06 <Figs> Data representation.
16:29:47 <asiekierka> Hi.
16:29:53 <Figs> Howdy
16:29:55 <asiekierka> Hi Slereah, ehird` and Figs.
16:30:27 <Figs> I feel crazy. :D
16:30:32 <Figs> whee.
16:31:15 <Figs> type systems, object orientation, constraints, logic, generics, functional programing, etc... @_@
16:33:05 <ehird`> i really want an esolang like befunge but with no data storage apart from the code field
16:33:05 <ehird`> :D
16:33:21 <ehird`> and no control structures except conditional ways to shift about stuff in the code field
16:33:25 <Figs> It would be interesting if we had a proper Type data type in regular programming that we could later instantiate...
16:33:44 <ehird`> We do.
16:34:01 <Figs> in some languages :)
16:34:07 <ehird`> It's called 'Class'. You'll find it in Smalltalk, Ruby, and several others.
16:34:12 <ehird`> In Io, it's called Object.
16:34:23 <ehird`> Because there are no classes. You just clone objects, modify them, and later clone them to create 'instances'
16:34:47 <Figs> prototype OO? :)
16:35:56 <ehird`> yep
16:35:56 <ehird`> :D
16:36:01 <ehird`> Io is very nice
16:36:04 <ehird`> it has no keywords
16:36:06 <ehird`> zilch
16:36:13 <Figs> do you read Squidi?
16:36:22 <ehird`> take a look at the sample code: http://www.iolanguage.com/about/samplecode/
16:37:25 <Figs> he's been posting for a while about a procedural generation concept for games that he's been thinking about for a while, and I think he's basically reinvented generics and inheritance in a different context
16:38:07 <Figs> which got me thinking about how we represent data in general
16:39:46 <Figs> IO isn't supposed to be esoteric, is it?
16:40:46 <ehird`> no, it isn't
16:40:52 <ehird`> but it is certainly esoteric in parts
16:40:54 <ehird`> all good languages are :)
16:41:02 <Figs> :P
16:41:27 * Figs points to the mathematicians and logicians
16:43:16 <Figs> I've been thinking that there's a second way to classify types other than inheritance: any type that matches some constrains (ex, has a property P, does ___, etc.)
16:43:16 <Slereah> Phew, I'm off the hook.
16:43:30 <Figs> hardly a new idea, of course :)
16:43:49 <Figs> but it's got my head running around again, I guess.
16:44:26 <ehird`> and yes
16:44:28 <ehird`> that's ducktyping
16:44:49 <Figs> I was thinking of something slightly different from ducktyping, I think
16:45:05 <Figs> ie, creation of new types later that effectively act as parents explicitly
16:45:14 <Figs> without having inheritance hierarchies
16:45:22 <Figs> (in the traditional sense)
16:46:47 <Figs> object Foo { property A,B,C... }; type Foo-Like {has A,B,C...}
16:48:18 <ehird`> yes
16:48:20 <ehird`> ducktyping
16:48:26 <ehird`> except "has" and "property" are implicit
16:49:36 <Figs> I guess you could think of it as an explicit version of ducktyping
16:49:50 <Figs> that's probably the best way to talk about it, I guess.
16:49:56 <ehird`> that's bad, though
16:50:10 <ehird`> ducktyping is all about implicitness in semantics, why add explicitness in syntax?
16:50:52 <Figs> object Cat {...} type Mammal {...} myFunction(Mammal xyz) {...}?
16:51:31 <ehird`> class cat { ... }
16:51:35 <ehird`> class mammal { ... }
16:51:59 <Figs> object and type were just the words that came to mind, how you do it doesn't matter :P
16:52:01 <ehird`> myFunction(xyz with-method make_sound) { xyz.make_sound(); }
16:52:13 <ehird`> myFunction(new cat) # meow
16:52:23 <ehird`> myFunction(new mammal) # not-implemented-error
16:52:30 <ehird`> myFunction(new object) # no matching function found
16:52:53 <Figs> you'd have to type xyz with-method make_sound over and over though, no?
16:53:32 <Figs> (if you have a bunch of functions that operated on things that make sounds)
16:54:03 <ehird`> class mytype = with-method make_sound;
16:54:09 <ehird`> myFunction(mytype xyz) { ... }
16:54:21 <Figs> there you go, that's exactly what I'm talking about :)
16:54:36 <Figs> just different syntax from what I wrote above
16:54:52 <Figs> but that's what I was trying to say
16:55:11 <Figs> my ability to express things today has just been shitty :P
16:55:36 <ehird`> no
16:55:38 <ehird`> because class cat
16:55:40 <ehird`> and class mammal
16:55:43 <ehird`> wouldn't have "has"
16:55:44 <ehird`> or "property"
16:55:55 <ehird`> well, Foo-Like is similar
16:55:59 <ehird`> but there is no "property a,b,c"
16:56:01 <ehird`> it's implicit
16:56:05 <Figs> with-method is just the same as "has" as far as I'm thinking
16:56:22 <Figs> I'm not really thinking about a specific syntax, just a general idea of relating things
16:57:03 <ehird`> its duck typing
16:57:16 <Figs> ok
16:57:36 <Figs> what language uses "class mytype = with-method make_sound;"? I'd like to take a better look at it
17:05:41 -!- ehird`_ has joined.
17:06:05 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
17:06:13 <Figs> :(
17:07:27 <ehird`_> heh
17:07:31 <Figs> yay!
17:07:37 <ehird`_> and what language?
17:07:41 <Figs> ?
17:07:43 <ehird`_> none! it was pseudocode :-)
17:07:47 <Figs> ah
17:07:54 <ehird`_> i can make a language for it if you want
17:07:54 <ehird`_> :P
17:08:01 <Figs> :P
17:08:17 <Figs> what I mean, I guess is that a lot of what I understand of duck typing would basically be like
17:08:37 <Figs> function Foo(a) { a.quack(); a.walkLikeDuck(); }
17:09:10 <ehird`_> that is duck typing
17:09:16 <ehird`_> mine just has checks.
17:09:24 <ehird`_> but it is basically equiv to your example
17:09:26 <Figs> eh,
17:09:28 <Figs> what I mean is
17:09:46 <Figs> you'd have to look in the method for the quack() and the walkLikeDuck()
17:10:31 <Figs> instead of seeing Foo(Duck a) {...now I know that 'a' must quack() and walkLikeDuck() without actually looking through the function...}
17:11:17 <Figs> but my class DonaldDuck doesn't ever have to declare that it is-a duck [through inheritance, etc]
17:11:59 <ehird`_> this is a syntax issue
17:12:10 <Figs> mostly
17:13:32 <Figs> I'm just sort of poking at the border between generics and duck typing, I guess
17:13:38 <ehird`_> + length [1 2 3] sum map lambda [x] [* x 2] [4 5 6] <-- pretty esoteric looking, isn't it?
17:13:53 <Figs> what is it? Haskell?
17:14:17 <Figs> and yes
17:14:56 <ehird`_> nah, i cooked it up just now
17:15:03 <Figs> ah :P
17:15:06 <ehird`_> it's just "func args", where args is a fixed number
17:15:11 <ehird`_> and, of course [...] for a list
17:15:18 <ehird`_> since the code is just a list in essence that works well
17:15:26 <ehird`_> and also makes it homonononomorphic, like lisp and factor
17:15:28 <ehird`_> however
17:15:32 <ehird`_> even more esoteric?
17:15:36 <ehird`_> + length . 1 . 2 . 3 nil sum map lambda . x nil . * . x . 2 nil . 4 . 5 . 6 nil
17:15:45 <ehird`_> got rid of [...] in favour of lisp-style cons'
17:17:14 <ehird`_> but the final esotericness?
17:17:16 <ehird`_> +l.1.2.3;S_\.x;.*.x.2;.4.5.6;
17:17:21 <ehird`_> made everything single-character.
17:17:33 <Figs> I think you can make it worse still :)
17:17:35 <ehird`_> Figs: implement the above. yes/no
17:18:14 <Figs> make it so operations like +, l, etc must be called by table ID in a list of all functions in the program...
17:18:20 <ehird`_> hahahah
17:18:28 <ehird`_> no i have a better idea
17:18:32 <ehird`_> remove named arguments from lambdas
17:18:44 <ehird`_> just have function composition (+ lambdas are curried)
17:18:48 <Figs> remove constants
17:18:53 <ehird`_> no :P
17:18:55 <ehird`_> well
17:18:56 <ehird`_> mayb
17:18:56 <ehird`_> e
17:18:58 <ehird`_> but first:
17:19:01 <Figs> make it so you have to generate them by function composition
17:19:23 <Figs> from 1 and -1 as functions in the table...
17:19:28 <ehird`_> +?.1.2.3;S_.*.2;.4.5.6;
17:19:40 <ehird`_> (renamed length to ?, removed lambda since with just composition you can just use lists)
17:19:50 <ehird`_> actually, if we have currying:
17:20:06 <ehird`_> wait, no
17:20:10 <ehird`_> can't have currying
17:20:12 <ehird`_> fixed number of arguments.
17:21:22 <ehird`_> +?.1.2.3;S_\.*.2;.4.5.6;
17:21:24 <ehird`_> there
17:23:31 <ehird`_> Figs: that's a pretty esoteric way of saying
17:23:34 <ehird`_> 33 don't you agree?
17:23:49 <Figs> so say you had like @3 is add, @5 is multiply, @6 is one @9 is -1... then making the number 20 is: @5 (@3 @6 (@3 @6 (@3 @6 (@3 @6 @6)))) (@3 @6 (@3 @6 (@3 @6 @6))) assuming I didn't fuck up
17:24:38 <Figs> you could make it worse by using weird numbers instead of 1 and -1... like, 13 and -47
17:25:17 <Figs> I feel evil
17:25:50 <ehird`_> ok, now remove the parens
17:25:55 <ehird`_> and make @x one character somehow
17:25:58 <ehird`_> and remove the spaces
17:26:17 <ehird`_> ok, let's say this
17:26:22 <ehird`_> hm
17:26:25 <ehird`_> how do we do:
17:26:50 <Figs> ohh
17:26:52 <Figs> :D
17:26:53 <ehird`_> "if first bit is 0, read the rest as a number then move onto the next byte and continue reading as binary"
17:26:54 <ehird`_> and
17:27:04 <ehird`_> "if first bit is 1, read rest as number and we're done with this number"
17:27:13 <ehird`_> and keep it in the range of displayable ascii chars
17:27:20 <ehird`_> and have the numbers be lookups
17:27:24 <Figs> nice
17:27:25 <ehird`_> its still TC since they can be bignums
17:27:37 <Figs> :D
17:27:59 <ehird`_> you'd get code like
17:28:07 <ehird`_> "~{£P"£+_C)+WA:R~£:$G_)£I_)|@~>W~@$F?£~@R>ASD(AW)(E"KJFpL~@Sld[aslkd09AEJ-0k-w039i90opak@:LASD8
17:28:09 <ehird`_> or someting
17:28:11 <Figs> A3huiol32*()#52#*90klVF#@#{-345____#$u980#@&$(*)@!$#*(HJ&*VVH*(#O@U%LL@#%>,../.2.3*%(#
17:28:14 <ehird`_> :D
17:28:52 <Figs> better yet, just restrict it to the top row symbols on the keyboard and every other one is "done with this number"
17:29:00 <Figs> ie, ~@$^*)+
17:29:05 <Figs> would be continuables
17:29:07 <Figs> and
17:29:09 <ehird`_> haha
17:29:14 <Figs> !#%&(_
17:29:16 <Figs> are ending
17:29:17 <EgoBot> Huh?
17:29:28 <Figs> even EgoBot is confused now :D
17:30:03 <Figs> but...
17:30:09 <Figs> don't make it so obvious :)
17:30:10 <Figs> like
17:30:15 <Figs> ~#$&() are continue
17:30:20 <Figs> and the rest aren't
17:30:24 <Figs> (so not every other one)
17:30:30 <Figs> (but some bizare set)
17:30:41 -!- puzzlet_ has quit (Remote closed the connection).
17:30:45 -!- puzzlet has joined.
17:30:55 <Figs> and restrict the number of characters per action to 5
17:31:00 <Figs> but
17:31:13 <ehird`_> ok, so now that we have the syntax
17:31:15 <Figs> make one of the functions a function that replaces a function
17:31:17 <ehird`_> let's define the standard table!
17:31:26 <ehird`_> (not your top-row syntax, mine :P)
17:31:31 <Figs> :P
17:32:14 <Figs> like, make kfC set the next value given to it to the function behavior described by a lambda given after it
17:32:26 <ehird`_> nononono
17:32:30 <ehird`_> totally wrong
17:32:33 <ehird`_> more like
17:32:51 <ehird`_> 0 takes two arguments, a lambda and a list, and returns a list with all elements applied to the lambda
17:32:55 <ehird`_> you deal in numbers
17:33:01 <ehird`_> the syntax just specifies numbers
17:33:29 <Figs> you could make it complicated by rotating the list in sets of 13
17:33:54 <ehird`_> no
17:33:56 <ehird`_> that's just dumb
17:34:02 <Figs> :P
17:34:18 <Figs> ok
17:35:04 <Figs> you could make it shift by the # of functions called in the program so far...
17:36:28 <Figs> or xor each byte returned with the #F called mod 31
17:36:54 * Figs stops.
17:37:08 <Figs> yeah, I'm just getting silly now
17:41:07 <Figs> hey
17:41:20 <ehird`_> hi
17:41:21 <Figs> I think the term for I was talking about is "structural typing"
17:41:29 <ehird`_> <Figs> you could make it shift by the # of functions called in the program so far...
17:41:31 <Figs> at least, reading about it, it sounds similar
17:41:32 <ehird`_> that's brilliant
17:41:38 <Figs> yay! :D
17:41:53 <ehird`_> hm
17:41:55 <ehird`_> shift which way?
17:42:04 <Figs> alternate in sets of three
17:42:09 <ehird`_> also,
17:42:13 <ehird`_> not #funcalls
17:42:19 <ehird`_> but #funcalls-in-source
17:42:21 <ehird`_> because
17:42:23 <ehird`_> if you GOTO
17:42:23 <Figs> < < >, < > <, < > <, repeat?
17:42:24 <ehird`_> or LOOP
17:42:29 <ehird`_> nondeterministically
17:42:37 <ehird`_> then -- it changes
17:42:39 <Figs> yeah :)
17:42:41 <ehird`_> so, not TC
17:42:48 <ehird`_> so, number of funcs seen in source code
17:42:48 <ehird`_> k?
17:42:53 <Figs> sure
17:43:16 <Figs> it's so complicated already, you'd probably have to program a computer to program in it to program anything significant in it
17:43:41 <ehird`_> :-)
17:43:42 <ehird`_> naw
17:44:23 <Figs> huh
17:44:27 <Figs> interesting ...
17:44:36 <ehird`_> i am going to write a compiler for it
17:44:41 <Figs> yay! :D
17:44:42 <ehird`_> compiling to C, using continuation-passing-style
17:44:45 <Figs> ;)
17:44:46 <ehird`_> so: no stack
17:44:47 <ehird`_> :D
17:44:52 <Figs> continuation-passing?
17:45:02 <ehird`_> let me explain
17:45:03 <Figs> kk
17:45:10 <ehird`_> (Don't wikipedia it, it's technical there)
17:45:19 <ehird`_> when you see
17:45:26 <ehird`_> (+ (f 1 2) (g 3 4))
17:45:33 <ehird`_> the compiler goes to +
17:45:38 <ehird`_> then pushes the current state
17:45:40 <ehird`_> then runs f
17:45:43 <ehird`_> then pops back to that state
17:45:43 <ehird`_> etc
17:45:47 <ehird`_> you know this.
17:45:49 <ehird`_> in CPS
17:45:52 <ehird`_> there is no stack
17:45:55 <ehird`_> it gets transformed to:
17:46:30 <ehird`_> (f 1 2 (LAMBDA-WITH-RESULT-AS-X (g 3 4 (LWRA-Y (+ X Y))))
17:46:32 <ehird`_> see?
17:46:35 <ehird`_> no stack
17:46:45 <ehird`_> you can just push the arguments and that function (the continuation) to the stack
17:46:47 <ehird`_> and GOTO
17:46:59 <ehird`_> then, when it's done, it continues executing from the lambda, called with the result
17:47:13 <ehird`_> it's not an interpretation strategy although you could use it that way
17:47:15 <Figs> I don't see yet, but let me think for a minute
17:47:18 <ehird`_> more of a compiling strategy
17:47:52 <Figs> f and g taking 3 params?
17:47:59 <Figs> with the third as the function called?
17:48:03 <ehird`_> err, wait
17:48:04 <ehird`_> I'm wrong
17:48:10 <ehird`_> (f 1 2 (LAMBDA-WITH-RESULT-AS-X (g 3 4 (LWRA-Y (+ X Y NIL-LAMBDA))))
17:48:10 <Figs> ok
17:48:14 <ehird`_> there, with NIL-LAMBDA you can see
17:48:21 <Figs> I think so
17:48:30 <Figs> then it becomes basically like tail-recursion?
17:48:32 <ehird`_> every F taking arguments N now takes N+1 arguments, and its first N arguments must be simple atoms
17:48:34 <ehird`_> "hello world"
17:48:34 <ehird`_> 2
17:48:37 <ehird`_> but not function calls, etc
17:48:45 <ehird`_> you execute the innermost function
17:48:50 <ehird`_> which then tailcalls the Nth argument
17:48:54 <ehird`_> which executes one less
17:48:54 <ehird`_> etc
17:48:57 <ehird`_> until you get to the toplevel
17:49:08 <ehird`_> you never need to push to a callstack
17:49:12 <ehird`_> every call is a tail call
17:49:18 <Figs> that's nifty
17:49:36 <ehird`_> indeed!
17:49:42 <Figs> I have to remember that one :D
17:50:14 <ehird`_> here's one way to think about it, Figs.
17:50:24 <ehird`_> the new extra parameter
17:50:25 <ehird`_> is "return"
17:51:26 <Figs> I think I get it :)
17:52:06 -!- Slereah- has joined.
17:52:18 <Figs> what are the limits of it?
17:52:50 <ehird`_> none
17:52:58 <ehird`_> any expression can be converted to it
17:53:16 <Figs> hmm
17:53:32 <Figs> cool
17:53:33 <ehird`_> http://en.wikipedia.org/wiki/Continuation-passing_style has a factorial and other examples
17:53:49 <ehird`_> the return parameter in them is called 'k'
17:53:52 <ehird`_> it's convention
17:55:20 -!- puzzlet has quit (Remote closed the connection).
17:55:21 -!- puzzlet_ has joined.
18:00:57 <Figs> what exactly is a "normal form"? O.o
18:01:06 * Figs is reading about ANF now
18:02:21 -!- Slereah has quit (Read error: 110 (Connection timed out)).
18:02:33 <pikhq> BNF, you mean?
18:02:40 <Figs> no
18:02:45 <Figs> Administrative Normal Form
18:02:46 * pikhq go boom
18:03:43 <Figs> is it just the "standard way" to represent a particular type of information? or does it mean more than just the regular meaning of "normal"?
18:07:03 <Figs> hrm. well there's also CNF (Chomsky Normal Form) which is a context free grammar without epsilon except optionally for the start rule, afaict.
18:27:18 -!- Jontte has quit (Read error: 113 (No route to host)).
18:28:41 -!- Jontte has joined.
18:35:14 -!- puzzlet has joined.
18:35:14 -!- puzzlet_ has quit (Remote closed the connection).
18:36:50 <asiekierka> hi
18:36:52 <asiekierka> back
18:37:11 <Slereah-> Welcome back.
18:45:55 <Figs> howdy!
18:51:10 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
18:52:03 -!- puzzlet has joined.
18:58:41 -!- bsmnt_bot has quit (kubrick.freenode.net irc.freenode.net).
19:00:02 -!- bsmnt_bot has joined.
19:08:50 -!- asiekierka has quit.
19:10:56 -!- SEO_DUDE has quit (Remote closed the connection).
19:20:43 <Figs> oh fuck.
19:21:04 <Figs> int foo,*bar;
19:21:06 <Figs> ...
19:21:27 <Figs> foo = 3/*bar;/*comment or division by deref?*/
19:21:27 <ehird`_> you idiot
19:21:28 <ehird`_> :P
19:21:35 <ehird`_> and heh
19:21:41 <ehird`_> where did i see that again
19:21:43 <ehird`_> reddit?
19:21:48 <Figs> eh
19:21:59 <Figs> that just killed my happy place. :(
19:22:49 <ehird`_> anyway
19:22:52 <ehird`_> trivially, it's a comment
19:23:00 <ehird`_> because /* out of a string ALWAYS means comment
19:23:16 <Figs> yeah, but it still makes me sad :P
19:24:16 <Figs> no syntax highlighter (or improperly working one) and lack of obvious */ might make you think it's supposed to be the other... :P
19:24:33 <Figs> reminds me of the \ in a comment...
19:25:42 <ehird`_> someone should make a c program with loads of stuff like that
19:25:47 <ehird`_> looking pretty trivial as if it does something
19:25:51 <ehird`_> but it really does something entirely different;
19:25:58 <Figs> :)
19:28:07 <Figs> O_o
19:28:13 <Figs> I just had a really fucked up idea
19:28:52 <ehird`_> what
19:28:54 <Figs> we should figure out how to write a compile-time "lambda" in C++ templates...
19:29:08 -!- oerjan has joined.
19:29:24 <Figs> I mean, it's technically turing complete...
19:29:26 <Figs> :D
19:29:30 -!- SEO_DUDE has joined.
19:29:51 <ehird`_> people have done it
19:29:57 <Figs> link?
19:30:01 <ehird`_> people have written factorials in it, people have solved the Queens problem in it
19:30:06 <ehird`_> it's not interesting any more
19:30:10 <Figs> Yeah, that's not what I meant though
19:30:28 <ehird`_> http://www.boost.org/libs/lambda/ does it
19:30:33 <ehird`_> and its widely used
19:31:09 <Figs> that's totally not what I meant :)
19:34:54 <ehird`_> yes
19:34:55 <ehird`_> it is
19:34:56 <ehird`_> :)
19:35:01 <ehird`_> http://wiki.answers.com/Q/Does_the_UNIX_has_GUI this is some kind of abstract poetry
19:35:22 <oerjan> <Figs> object Foo { property A,B,C... }; type Foo-Like {has A,B,C...}
19:35:43 <oerjan> reinventing haskell type classes?
19:36:03 <oerjan> or perhaps Ocaml object types
19:39:16 <oerjan> or would that be ocaml polymorphic records
19:40:27 <oerjan> anyway that's probably "structural typing", assuming it's static
19:48:40 <oerjan> um, you already found out
19:50:14 -!- SEO_DUDE has quit (Remote closed the connection).
19:50:33 <Figs> whee
19:50:44 <Figs> Yeah, I already found it, but thanks :D
19:50:59 <Figs> ehird`_: no, hang on a second...
19:51:24 <Figs> http://rafb.net/p/oVaoH683.html
19:52:52 <Figs> there you go :D
19:52:59 <Figs> think like that, only much worse...
19:54:06 <ehird`_> i know
19:54:09 <ehird`_> Boost's lambda
19:54:17 <oerjan> "normal form" usually means some kind of reduced representation, after you've done a set of simplifications or calculations
19:54:38 <ehird`_> oerjan: e.g. 2 + 2's normal form is 4
19:55:06 <Figs> ehird`_: I thought Boost's lambda was rather different, ie, the function gets called at runtime
19:55:12 <oerjan> but exactly what normal form means depends on what simplifications you are talking about
19:55:24 <Figs> whereas everything I'm talking about never gets past compiling
19:55:43 <Figs> thanks oerjan
19:55:50 <Figs> :)
19:56:52 <oerjan> i could add Cantor normal form which is a normal form for transfinite ordinals, disjunctive and conjuctive normal forms which are normal forms for boolean expressions, etc.
19:58:06 <ehird`_> Figs: basically you want what you linked but with arbitary arguments
19:58:07 <ehird`_> right?
19:58:18 <ehird`_> & results
19:58:32 <Figs> sort of
20:05:34 <bsmntbombdood> damn i wish i could breathe fire
20:12:15 <oerjan> <Figs> foo = 3/*bar;/*comment or division by deref?*/
20:12:34 <oerjan> thus haskell's decision to avoid unary operators
20:13:10 <oerjan> other than unary minus, no two operators can follow each other
20:13:32 <oerjan> although sadly {- starts a comment
20:13:45 <ehird`_> (-) = deref
20:13:49 <ehird`_> wait no
20:13:50 <ehird`_> that's
20:13:53 <ehird`_> - x = deref
20:13:54 <ehird`_> mwahahahaa
20:14:57 <oerjan> otoh { - is probably not legal haskell unless you write a very weird Num instance
20:15:28 <oerjan> or wait...
20:16:30 <oerjan> darn, case -2 of { -2 -> "alas"; _ -> "nope" } is possible
20:17:40 <ehird`_> oerjan's dreams of sensible haskell syntax are shattered!
20:18:18 <oerjan> if they had chosen {* or something it would not have been a problem, since * is only infix :(
20:18:37 <Figs> lol
20:18:39 <oerjan> oh, there are much worse things in haskell syntax
20:18:40 <Figs> :(
20:21:01 <oerjan> the report is not sensible on precedence resolution for example - mixing it in with general parsing. although every compiler ignores the corner cases and resolves separately anyway
20:22:02 <oerjan> afk
20:32:09 <Figs> ergh
20:32:15 <Figs> all this metaprogramming is breaking my mind :D
20:54:06 <oerjan> i never metapr*OUCH, STOP IT!*
21:01:26 -!- oerjan has quit ("Out to meta food").
21:03:23 <ehird`_> i never metaclass that didn't talk about itself
21:03:32 <ehird`_> *GROAN*
21:11:02 <pikhq> <typename T>T foo;
21:19:43 <ehird`_> pikhq: oh my god.
21:19:44 <ehird`_> :O
21:21:43 <pikhq> foo<int> = 5; foo<bool> = false;
21:21:49 * pikhq laughs maniacally
21:22:56 <ehird`_> oh my fucking god
21:22:56 <ehird`_> die
21:39:06 <Figs> rofl?
21:39:52 <Figs> (_._)
21:40:27 <Figs> I'm actually starting to like Java
21:40:34 <Figs> it's a bit more sane than C++
21:41:09 <Figs> on the other hand, it's kinda verbose
21:41:29 <Figs> I do like the fact that I can set just about everything to null and return null all over the place
21:41:41 <Figs> makes life that much simpler
21:43:05 <ehird`_> Figs: use a real language for a bit
21:43:05 <ehird`_> :)
21:43:13 <Figs> hehe :P
21:43:30 * Figs starts trying to get work coding in Brainfuck...
21:43:42 <Figs> j/k
21:43:51 <Figs> I'm learning Java for my CS class
21:44:01 <ehird`_> earmuffs. use them
21:44:07 <pikhq> In C++, you can return null.
21:44:10 <ehird`_> on any account do not let yourself be lost!
21:44:20 <pikhq> Make every function a void *.
21:44:22 <pikhq> ;p
21:44:32 <Figs> that's the obnoxious way though :)
21:47:11 <ehird`_> return (MyRetVal)null;
21:48:14 <ehird`_> return nix_ObjectFromState(state, NIX_NIL);
21:51:43 -!- Sgeo has joined.
21:52:42 <pikhq> typeof(<typename T> T)
21:52:59 <ehird`_> head, it's exploded
21:53:05 <pikhq> :)
21:54:11 <ehird`_> ...
21:54:13 <ehird`_> what does that return
21:54:42 <pikhq> <typename T> T
21:56:01 <pikhq> <typename T>T foo<typeof(stack<int> foobar.top)> = 5;
21:56:05 <pikhq> What type is foo?
21:56:23 * pikhq is an evil bastard
21:56:25 <ehird`_> umm
21:56:27 <ehird`_> your mother
21:56:31 <Figs> I don't think that's valid C++
21:56:38 <ehird`_> Figs: it is, i know that much
21:56:49 <pikhq> typeof isn't a C++ keyword.
21:56:57 <pikhq> It's a GNU C++ keyword, however.
21:57:11 <Figs> what are you assigning 5 to?
21:57:31 <pikhq> foo, obviously.
21:58:01 <Figs> I don't think that's a valid way to write that.
21:58:08 <Figs> lemme play with it
21:58:27 <pikhq> Fine, fine.
21:58:31 <pikhq> stack<int> foobar;
21:58:35 <pikhq> foobar.push(5);
21:58:44 <Figs> (usually, vector<int> foo, no? not vector foo<int> and you don't put the <typename T> before declaring a variable like that in normal use.
21:58:51 <jix> pikhq: isn't top a function returning a int()
21:58:58 <jix> uh int&
21:59:17 <pikhq> <typename T>T foo<typeof(foobar.top())> = 5;
21:59:20 <pikhq> jix: Might be.
21:59:21 * ehird`_ is suprised nobody asked wtf "return nix_ObjectFromState(state, NIX_NIL);" was
21:59:51 <pikhq> Figs: The template on vector is on the class, not on the *variable*. ;)
22:00:04 <Figs> that's my point.
22:00:23 <Figs> <typename T>T foo<typeof(stack<int> ...
22:00:39 <Figs> <typename T> T foo shouldn't happen like that
22:00:54 <Figs> unless you're doing something else that I'm not thinking of
22:01:21 <Figs> you might get away with it by specializing a function or something, but then you wouldn't be assigning 5
22:01:27 <Figs> and you'd need ()
22:01:33 * Figs brain-splodes
22:01:45 <Figs> so
22:01:52 <Figs> in other news, Malibu is on fire again...
22:06:59 * pikhq declares C++ pure insanity
22:07:12 <pikhq> Seriously: int &foo? WTF?
22:17:53 -!- jix has quit ("CommandQ").
22:41:35 <bsmntbombdood> what's int &foo?
22:42:04 <Figs> int& foo
22:42:06 <pikhq> A reference to foo.
22:42:17 <Figs> whee.
22:42:29 <bsmntbombdood> huh?
22:42:30 <pikhq> Not a pointer, mind.
22:42:44 <pikhq> void add(int &x){x++;}
22:42:51 <pikhq> int foo = 5;
22:42:55 <pikhq> add(foo)
22:43:01 <Figs> it's basically the same thing as a pointer, just you can't change what it points to, and it can't be null...
22:43:01 <pikhq> foo is now 6.
22:43:11 <Figs> (and the syntax is sometimes more prettyful)
22:43:27 <Figs> yay prettyful!
22:43:33 <Figs> butterflies and prettyful flowers.
22:43:36 <Figs> Achoo!
22:43:44 * Figs = braintoast.
22:43:49 <Figs> good night.
22:43:52 * Figs disappears
22:43:55 -!- Figs has quit ("Java user signed off").
22:43:58 * pikhq cuts a chunk out of a penny
22:44:26 <bsmntbombdood> c++ is shtupppid
22:57:31 * pikhq fashions the penny into a legal-tender blade
22:58:05 <bsmntbombdood> not legal tender if it's cut up
22:58:33 <pikhq> If greater than 51% of it is still in one piece, it remains legal tender.
23:41:47 -!- immibis has joined.
23:45:01 -!- ehird`_ has quit (Remote closed the connection).
23:45:10 -!- oerjan has joined.
←2007-11-23 2007-11-24 2007-11-25→ ↑2007 ↑all