00:21:58 -!- CakeProphet has changed nick to SevenInchBread.
01:24:01 -!- nazgjunk has quit (Remote closed the connection).
01:40:31 -!- pikhq has joined.
01:48:45 <ihope> Gah! Darn Google Groups.
01:52:04 <ihope> Luckily enough, I can get this down in three sentences.
01:52:22 <GregorR> pikhq: Do you think I should remove the special scope-reassignment of functions with assignment in Plof?
01:52:50 <GregorR> pikhq: It occurs to me that I'm not actually using function reassignment much, and it may be more confusing than it's worth.
01:53:05 <pikhq> Given that I didn't know that was *there*. . .
01:53:36 <GregorR> var someObject = :[ /* content */ ]; someObject.newFunction = :{ /* this function will run in someObject's scope, not this one */ };
01:54:15 <pikhq> Um, that's actually useful.
01:54:18 <GregorR> Unfortunately, the side effect is that I can't do things like:
01:54:27 <pikhq> It might be nice to use a different syntax, though.
01:54:30 <GregorR> var a = (x as function):{ var x2 = x; x2(); };
01:54:49 <GregorR> (As x2 would have a different scope than x was intended to be called in)
01:55:04 <pikhq> var someObject = someObject : :[newFunction = :{ /* Here's your function. */ }];
01:55:21 <pikhq> Remove the var bit.
01:55:40 <GregorR> That would have the same effect, but would change someObject, which would be bad if you had child objects of it.
01:58:10 <pikhq> someObject.newFunction = someObject.:{};?
01:58:37 <GregorR> Explicitly specifying the scope of an object at definition time.
01:58:47 <pikhq> Yeah. It *may* work.
02:01:17 <GregorR> Doesn't parse very cleanly with that syntax, but that's solvable.
02:01:42 <pikhq> It's a matter of getting a parsable syntax for it, after all. . .
02:02:30 <GregorR> someObject.newFunction = someObject:::{...};
02:16:04 <GregorR> SevenInchBread: Just syntax.
02:17:33 <SevenInchBread> assigns a function to a variable in a different scope...
02:18:11 <GregorR> someObject.:{}; is difficult to parse as it is, since '.' and '{' are at the same precedence.
02:18:29 <GregorR> Trying to figure out what to change to get syntax something like that without making parsing any more complex.
02:18:39 <GregorR> The problem there is this:
02:18:48 <GregorR> var a = (x as function):{ var x2 = x; x2(); };
02:19:32 <GregorR> Ideally, x2() would be the same as x().
02:19:48 <GregorR> Well, the problem is that that would reassign the scope.
02:19:59 <GregorR> But in that case, you don't want to reassign the scope.
02:20:02 <SevenInchBread> hmmm... well.... what kind of scoping is it? global-by-default?
02:20:45 <GregorR> By the current convention, x is in the scope that it was defined, and x2 is in the scope of function a.
02:21:30 <SevenInchBread> well... variables are implicitly local, or am I wrong?
02:21:46 <GregorR> They have the scope in which they were defined.
02:23:57 <SevenInchBread> hmm.... if you have a direct reference to the object... would it be much of a problem what scope you're in?
02:25:41 <GregorR> If you want to make a function be in a prototype object, the function as-declared will not have a direct reference to the object upon which it is run.
02:26:29 <SevenInchBread> ah.... I see.... so you need a sort of implicit way to add members/attributes/whatever to the prototype.
02:26:50 <GregorR> Currently, that's easy because the scope will be reassigned.
02:26:57 <GregorR> But it causes problems elsewhere.
02:28:26 <SevenInchBread> self being the scope from which the function was accessed.... maybe?
02:29:09 <GregorR> Umm, if I call someObject.foo(), I'm calling it from a scope which would not be an appropriate 'self' ...
02:29:21 <SevenInchBread> makes swapping methods between objects easier.... since self always refers to the containing scope for that function.
02:29:43 <SevenInchBread> no I mean.... make self implicitly the object from which foo was accessed
02:30:00 <SevenInchBread> .....not sure how you would program that to make sense though
02:30:30 <GregorR> I'm not sure if that solves the base problem :P
02:31:49 <GregorR> var a = (x as function):{ var x2 = x; x2(); }; // as Plof is currently designed, this is useless, and worse, an equivalent can't be easily defined.
02:32:18 <SevenInchBread> ...I don't understand the syntax... what's the colon for?
02:32:35 <GregorR> Don't worry about that, just know that it's a function accepting a function as an argument.
02:33:58 <GregorR> It's then assigning that function to its own variable, x2. But by the current definition, that changes the scope in which x2 will be run, so x2 won't work (as expected).
02:34:30 <GregorR> But the alternative makes adding functions to prototypes not work well.
02:34:45 <SevenInchBread> so the problem sems to be.... you have a fairly simple way to designate where variables are READ... but not a clear way ro specify where they're WRITTEN.
02:35:16 <GregorR> ............................. what?
02:37:00 -!- ihope has quit (Read error: 110 (Connection timed out)).
02:37:05 <SevenInchBread> just find where the variable is declare... and that's the scope to assign it to?
02:37:07 <GregorR> I don't think the problem that you think is the problem is the problem X-P
02:37:21 <GregorR> That's what's done right now.
02:37:45 <GregorR> ............................. OK, so I'll remove the colon, it's functionally equivalent :P
02:37:54 <GregorR> var a = (x as function){ var x2 = x; x2(); };
02:38:12 <GregorR> It's irrelevant what it does in this case X_X
02:38:24 <GregorR> I don't want to add to the confusion of trying to discuss a totally unrelated problem.
02:38:41 <SevenInchBread> >.> if I don't get the syntax... I can't decipher what's going on...
02:39:11 <GregorR> There are no colons in that example! :P
02:39:30 <GregorR> Is it "the colon thing" you don't understand, or the syntax in general?
02:40:27 <SevenInchBread> I figured out the colon thing... thin and thick functions right?
02:40:58 <SevenInchBread> ....now I just don't know what that means... you've defined an anonymous function next to a type casted function?
02:41:35 <SevenInchBread> ah wait.... do function calls require parenthesis? If not.... then you're calling (x as function) with {stuff} as the only argument, yes?
02:42:04 <oerjan> um, i think he is defining a function with one argument, x
02:43:06 <SevenInchBread> I thought it was... something being evaluated just before the lambda.
02:43:55 <GregorR> As it is, when I assign x to x2, x2 gets the content of the function, but the scope when called will be different.
02:44:41 <GregorR> Yeah. And it was necessary for me to do that for adding functions to objects to work properly.
02:44:46 <GregorR> But it has a nasty side-effect :(
02:45:06 <SevenInchBread> is it possible to have lexical functions and dynamic functions?
02:45:15 <SevenInchBread> or have lexical variables and dynamic variables perhaps?
02:45:21 <oerjan> a language without lexical scoping is not Properly Functional (TM)
02:46:04 <SevenInchBread> the variables that are undefined in the function are... basically dynamically gotten.
02:46:10 <GregorR> The default scope of a function is the scope in which it was defined, e.g. lexical scoping.
02:46:20 <GregorR> But, as a functional language, Plof is Ridiculously Impure (TM).
02:46:21 <oerjan> the problem is how to refer to variables of the current object.
02:46:44 <oerjan> and something self-like might be cleaner.
02:47:15 <GregorR> /Getting/ self would be nasty at best.
02:47:33 <SevenInchBread> I think having lexically defined or dynamically defined variables would be interesting.
02:47:43 <oerjan> the python solution seems to work well.
02:48:10 <GregorR> It's not really comparable.
02:48:14 <oerjan> i don't necessarily mean all of it.
02:48:33 <oerjan> just the part about binding functions to methods with the x.f construction
02:48:37 <SevenInchBread> like... you can't assign arbitrary functions to a Python object and expect them to work like methods.
02:49:11 <oerjan> well, you can do it to a class
02:49:48 <SevenInchBread> yeah... wouldn't work out well..... hmmm... how does IO fix this dilemma?
02:49:52 <oerjan> i suppose the problem is you might want to access unbound methods too
02:50:50 <SevenInchBread> a function that doesn't access self is effectively unbound
02:51:05 <oerjan> ok, simply have an assignment that tags a function as a method.
02:51:41 <GregorR> e.g., an assignment operator which changes scope.
02:52:06 <oerjan> not all of the scope just the self
02:52:06 <SevenInchBread> like there's a really simple way to just make it all work with one assignment operator.
02:52:40 <SevenInchBread> couldn't all assignments with functions treat functions as methods?
02:53:03 <GregorR> oerjan: As it is, functions defined within an object have a parent scope of the object, and so 'self' is unnecessary. It would be confusing for adjunct methods to require 'self', but internal methods not to. Also, it would mean you couldn't copy a method from one object to another.
02:53:14 <SevenInchBread> ....that's basically what Ruby does... a function is a method that simply never refers to self.
02:54:17 <oerjan> i know, but i think it would be problematic in any case. what if you copy to an object that has a different set of fields, some of which have the same name as globals?
02:54:35 <GregorR> I suppose I may have to *sigh*
02:54:58 <SevenInchBread> what's the problem with making anonymous functions bound to the scope they get assigned to?
02:55:16 <oerjan> that you then don't get closures.
02:55:18 <GregorR> var a = (x as function){ var x2 = x; x2(); };
02:55:29 <GregorR> ^ That's the problem with it :)
02:56:13 <SevenInchBread> I'm not sure I understand... wouldn't x2 be called in the scope of the "module" (or whatever plof calls it)
02:56:39 <GregorR> ... x2 is called in the scope of the function assigned to a.
02:57:22 <SevenInchBread> which has access to... the global scope in which a is defined, right?
02:57:36 <GregorR> Right. But 'x' was presumably defined in some other scope.
02:57:44 <GregorR> And will be expecting variables from it.
02:57:55 <oerjan> this resembles the lisp mess with lambda vs. function, doesn't it?
02:58:34 * GregorR is not familiar with that particular mess ... not very familiar with LISP.
02:58:52 <SevenInchBread> hmmmm..... if x2 is lexically scoped, what's the problem?
02:58:57 <oerjan> lambda is dynamically scoped, function is lexical, i think
02:59:07 <GregorR> SevenInchBread: x2 was assigned x.
02:59:26 <GregorR> SevenInchBread: So x2 will be called with a's scope, rather than x's scope. However, the function is still x.
03:00:00 <SevenInchBread> right... the interpreter would make no distinction between literal lambda assignment and variably expanded assignment.
03:00:43 <SevenInchBread> ...so, what's the difference between thin and thick functions again?
03:01:00 <GregorR> When you return from a function, it falls through all the thin functions and returns from the nearest thick function.
03:01:46 <GregorR> There are no blocks but functions. But if you do:
03:01:54 <SevenInchBread> a return in a thin function...... returns from the thin function it's defined in.
03:02:06 <SevenInchBread> it's so you can do things like return in an if statement
03:02:20 <GregorR> Since you're really passing 'if' a function.
03:02:34 <GregorR> It is hackish, but it's not as bad as what I had in Plof1 :P
03:02:44 <GregorR> It's the intersection between functional and imperative programming X_X
03:03:00 <SevenInchBread> could you maybe do return if(whatever, {blah;blah;blah;return x}, {return whatever});
03:03:16 <SevenInchBread> have the if statement return the return value of the executed function.
03:03:29 <GregorR> What if you only want one side of the if to return?
03:03:59 <GregorR> Like I said, intersection between functional and imperative :)
03:04:19 <SevenInchBread> I thought thick and thin functions were something like ios blocks and methods....
03:04:50 <GregorR> They're sort of similar, but far more interchangeable.
03:05:20 <oerjan> what if you make it so only thick functions get reassigned scope?
03:05:49 <SevenInchBread> heh... basically what if you make thin functions dynamical and thick functions lexical. :)
03:06:03 <oerjan> no, the other way around
03:06:27 <GregorR> var a = (x as thick):{ var x2 = x; x2(); }; // why shouldn't this work?
03:06:59 <oerjan> because a thick function becomes a method...
03:07:40 <SevenInchBread> hmm... typecasting thin and thick functions sounds like tricky business.
03:07:43 <oerjan> you could have automatic conversion between them.
03:08:29 <oerjan> (x as thin) would mean, don't reassign scope for x
03:08:48 <GregorR> Except that it would also mean that it's a thin function X_X
03:09:22 <oerjan> yes, but encapsulation is trivial
03:10:24 <SevenInchBread> that example.... or is it just as a "doesn't it just make sense that it should work this way" example.
03:10:29 <oerjan> if we take the smalltalk option that return can only return from methods...
03:11:05 <GregorR> I don't want to make this distinction between "methods" and "functions," especially since there are plenty of global functions that return.
03:11:45 <SevenInchBread> ah okay yeah... you want thick and thin functions to be largely interchangable thanks to type conversion
03:13:06 <SevenInchBread> heh.... this is nothing.... I had the insane idea of defining list-splits, attribute-access, and function calls with the same operator.
03:13:44 <oerjan> whitespace overloading anyone?
03:13:51 <SevenInchBread> object attribute (called series of list (items with (subcalls)) huge parsing dillemma)
03:16:21 <oerjan> actually that resembles some thoughts i have been having on ALPACA's syntax
03:17:18 <SevenInchBread> it was... quite strictly... "all functions are one argumented"
03:18:17 <oerjan> you do know about combinatory logic, right?
03:19:01 <SevenInchBread> I simplified things quite muchly with good-ol comma-separate lists.
03:21:06 <SevenInchBread> [do stuff to things] if (x > 3) else [do (other stuff) to things] ....although if I figure out some crazy way to unify expressions with functions... I can make it look like
03:21:22 <SevenInchBread> (do stuff to things) if (x > 3) else (do (other stuff) to things)
03:22:56 <SevenInchBread> ....actually I just figured out how... but it's a little unintuitive to explain the semantics.
03:26:55 <SevenInchBread> basically you have expression wrapped up in an expression object of sorts.... and if the message isn't defined on the expression, the expression is evaluated and it gets sent to the returned object.
03:27:44 <oerjan> now if you let obj meth = meth obj, (i.e. objects applied to things reversely apply them back) and use currying, then attribute access and function application _can_ have the same syntax.
03:30:21 <SevenInchBread> functions are objects that accept one message, and puts it into the source code.
03:30:47 <oerjan> now if you interpret (a b c) as \f. f a b c, then you can make lists of attributes interpolate
03:31:13 <SevenInchBread> and... since lists are single messages... (you, can, pass, multiple, arguments)
03:32:30 <oerjan> eh, are we talking about the same thing?
03:32:50 <oerjan> i was describing my ideas about ALPACA.
03:33:47 <oerjan> ALPACA conditions, suitably generalized, sort of look like a list of attributes applied iteratively.
03:34:03 <oerjan> but sometimes a function argument gets thrown in.
03:34:58 <oerjan> like ^ is an attribute to find the cell above the current one
03:36:48 <oerjan> except i don't think the original ALPACA allows you to iterate them - you have to stay within the 8-cell neighborhood.
03:37:04 <oerjan> but that is what i mean by suitably generalized.
03:37:14 <SevenInchBread> I'm trying to make creating objects suitably convient... because I think you could do a lot of nifty stuff with constructions... instead of the typical return-the-desired-value-immediately thing.
03:38:09 <SevenInchBread> like (x + 1) if (x > 3) will return a structure of sorts that works like a typical expression... but with an added else method.
03:38:38 <SevenInchBread> if the next message is defined on the expression... it's execute... otherwise the expression is evaluated and the message delegated to the return.
03:40:48 <oerjan> everything is guaranteed to behave as if nothing is evaluated until it is needed.
03:40:48 -!- helios24 has quit (Read error: 104 (Connection reset by peer)).
03:41:34 <SevenInchBread> oerjan, hmmm... does it preserve the evaluation... so it only evaluated once instead of everytime it's needed?
03:41:58 <oerjan> in any reasonable implementation yes
03:42:23 -!- helios24 has joined.
03:42:32 <oerjan> although evaluating it _every_time_ happens to be equivalent except in speed, so strictly speaking that is legal too
03:42:35 <SevenInchBread> depends on how you define the lanauge.... in the case of Sophia... it's whenever a message is passed to it.
03:44:30 <oerjan> in Haskell a value is needed when it is investigated by something that is itself needed.
03:45:05 -!- Sgeo has joined.
03:45:31 <oerjan> if a function call f x is needed, the function f will be. x may or may not be.
03:46:41 <SevenInchBread> hmm... so nothing is evaluated until something that is being evaluated needs it to be evaluated in order for it itself to be evaluated?
03:47:18 <oerjan> indeed, starting from the Main.main function, which is the only thing automatically needed.
03:47:44 <oerjan> or from whatever you give interactively if using a repl
03:49:47 <oerjan> or rather, main is evaluated to an IO action, which is performed, which may cause further evaluations.
03:51:35 <oerjan> there are however a couple of functions to get around lazy evaluation.
03:52:32 <oerjan> seq a b pretends to need a, evaluating it, then evaluates b and returns it.
03:53:04 <oerjan> and f $! x = seq x (f x)
03:55:19 <oerjan> also you can annotate record fields with ! so that they are automatically evaluated when the whole record is.
04:05:44 -!- SevenInchBread has quit (Read error: 113 (No route to host)).
04:57:22 -!- Sgeo has quit ("Ex-Chat").
05:39:13 -!- oerjan has quit ("leaving").
07:00:15 -!- FunnyMan3595 has joined.
07:03:54 -!- FunnyMan3595 has left (?).
07:19:19 -!- jix__ has joined.
07:39:43 -!- fax has joined.
07:47:42 -!- jix__ has quit ("This computer has gone to sleep").
07:50:07 -!- jix__ has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:22:36 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
09:22:01 -!- puzzlet_ has joined.
09:33:35 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
10:32:16 -!- puzzlet_ has quit (zelazny.freenode.net irc.freenode.net).
10:32:17 -!- sp3tt has quit (zelazny.freenode.net irc.freenode.net).
10:34:40 -!- puzzlet_ has joined.
10:34:40 -!- sp3tt has joined.
11:09:07 -!- ihope_ has joined.
11:09:16 -!- ihope_ has changed nick to ihope.
13:10:44 -!- pikhq has quit (Remote closed the connection).
13:11:03 -!- pikhq has joined.
14:11:12 * SimonRC hav drewn a pikcher: http://compsoc.dur.ac.uk/~sc/art/langs.png
14:16:59 <fax> I love it!!!!
14:17:14 <fax> thats going on my wall as soon as I fing a printer
14:19:41 <SimonRC> They vary between the languages themselves and their stereotypical users
14:20:05 <SimonRC> Perl and Java are based on people I know.
14:20:32 <fax> do APL and stuff
14:21:02 * fax reads about epigram
14:21:09 <SimonRC> I am not sure what they should look like
14:21:24 <fax> APL is an anarchist
14:22:49 <fax> wow epigram looks interesting
14:23:28 <SimonRC> I know one of the main developers, otherwise I would not know about it.
14:24:05 <SimonRC> I recommend learning Haskell, then learning the GADT extension to haskell before trying to tackle Epigram.
14:24:35 <fax> I wrote a LOGO interpreter in haskell
14:24:40 <fax> but its the only program I wrote
14:33:45 <SimonRC> the fact that you can write that as your first program shows what a poerful language Haskell it :-P
14:35:03 <fax> http://fax.twilightcoders.net/files/LOGO.zip
14:35:09 <fax> I think its awful code
14:35:40 <fax> this is the usermanual http://img293.imageshack.us/img293/449/logovz4.png
14:37:18 -!- ihope has quit (Read error: 110 (Connection timed out)).
14:40:05 <fax> I got really pissed off with the state of implementations of scheme
14:40:15 <fax> & went on a rampage & wrote this
14:40:29 <fax> in scheme48 I could use glut but not networking at the same time
14:47:26 <SimonRC> OTOH, you got a head-start as you knew scheme and the libraries you were using
14:47:53 <SimonRC> I don't use {;} much. maybe once every few hundred lines to fit something all on one line
14:49:08 <SimonRC> I would have said "type M = ReaderT (Map String Float, Map String Function)"
14:49:09 <fax> I dunno I think that I wrote really bad haskell because I dont have any exp like writing things well
14:49:17 <fax> Whats that for?
14:50:00 <fax> M is what?
14:50:10 <fax> oh variables and functions
14:51:06 <SimonRC> do you knw about monad transformers?
14:51:35 <fax> I wanted to write a monad so I could make the turtle move 20 pixels per second
14:51:37 <fax> but I gave up by then
14:51:42 <fax> maybe ill do it sometime
14:54:27 <SimonRC> M would allow you to have the current bindings available without haveing to explicitly pass them around so much
14:54:49 <SimonRC> There's a tutorial about making a lisp interpreter that explains that sort of thing
14:55:08 <fax> oh yeah I skimmed the tutorial, I think ill read that properly then
14:55:27 <fax> http://halogen.note.amherst.edu/~jdtang/scheme_in_48/tutorial/overview.html
15:02:31 -!- jix__ has joined.
15:07:53 -!- jix__ has changed nick to jix.
15:12:44 <SimonRC> The problem with colonising other planets via STL means is that if you can build the damn colony ships there is no point sending them out of Earth orbit.
15:20:20 -!- crathman has joined.
15:21:22 -!- ihope_ has joined.
15:21:30 -!- ihope_ has changed nick to ihope.
15:37:25 <SimonRC> The Daily WTF is launching OMGWTF -- "The Olympiad of Misguided Geeks at Worse Than Failure Programming Contest"
15:39:45 -!- goban has quit (Connection timed out).
15:47:11 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
16:17:14 -!- goban has joined.
16:39:45 -!- goban has quit (Connection timed out).
16:43:22 -!- sebbu has joined.
16:51:52 -!- pikhq has quit (Read error: 110 (Connection timed out)).
16:54:40 -!- helios24 has quit (zelazny.freenode.net irc.freenode.net).
16:54:41 -!- bsmntbombdood has quit (zelazny.freenode.net irc.freenode.net).
16:54:41 -!- SimonRC has quit (zelazny.freenode.net irc.freenode.net).
16:54:43 -!- bsmntbombdood has joined.
16:54:44 -!- SimonRC has joined.
16:54:46 -!- helios24 has joined.
16:58:27 -!- pikhq has joined.
17:27:05 -!- goban has joined.
17:52:43 -!- goban has quit (Connection timed out).
17:53:01 -!- goban has joined.
21:01:11 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:38:41 -!- oerjan has joined.
21:47:19 <oerjan> SimonRC: those _are_ horns on the Cobol guy, right?
21:47:50 * oerjan wants to be a mix of the Scheme, Intercal and Epigram guy
22:14:09 <SimonRC> he just has a bad combover
22:19:14 -!- goban has quit (Connection timed out).
22:22:51 -!- nazgjunk has joined.
22:29:15 -!- puzzlet has joined.
22:29:54 -!- puzzlet_ has quit (Read error: 54 (Connection reset by peer)).
23:35:43 -!- goban has joined.
23:46:26 -!- crathman has quit ("ChatZilla 0.9.78.1 [Firefox 2.0.0.3/2007030919]").