2003-07-29.txt:22:19:11: <lament> Are there any hierarchitectitiptitoploftical languages?
2006-08-24.txt:05:56:01: <GregorR> http://www.codu.org/plof/
2006-08-24.txt:06:00:22: <Arrogant> Ploftastic.
2006-08-24.txt:06:01:54: <GregorR> Well, Plof is a hybrid between OO and functional.
2006-08-24.txt:06:03:18: <GregorR> Yeah, that's true of Plof too.
2006-08-24.txt:06:03:49: <GregorR> Plof isn't intended to be estoeric.
2006-08-24.txt:06:04:55: <GregorR> Mixins in Plof:
2006-08-24.txt:06:07:58: <thematrixeatsyou> is there an article for this Plof stuff?
2006-08-24.txt:06:08:09: <GregorR-L> http://www.codu.org/plof/
2006-08-24.txt:22:08:12: <GregorR-W> http://www.codu.org/plof/index.php?title=IfFormat < Takin' votes :P
2006-08-24.txt:22:24:26: <GregorR-W> http://www.codu.org/plof/index.php?title=LongWords
2006-08-25.txt:21:18:11: <GregorR-W> http://www.codu.org/plof/2js/
2006-08-25.txt:21:20:52: <GregorR-W> In case you couldn't guess, it compiles Plof to JS.
2006-08-25.txt:21:21:00: <GregorR-W> Well, a subset of Plof.
2006-08-25.txt:22:25:02: <GregorR-W> http://www.codu.org/plof/index.php?title=Plof%20Spec (search "set math")
2006-08-25.txt:23:33:06: <GhostOfGregor> ihope: So long as what you design is Plof.
2006-08-26.txt:06:31:22: <GregorR> plof2js gains more features >: )
2006-08-26.txt:06:59:23: <GregorR-L> Try http://pastebin.ca/149864 on http://www.codu.org/plof/2js/
2006-08-26.txt:08:18:40: <GregorR-L> Plof has good ol' exceptions ^^
2006-08-26.txt:08:24:16: <GregorR-L> Also, Plof is a hybrid language :P
2006-08-27.txt:00:16:43: <GregorR-L> TYPEINFO IN PLOF!!!!!
2006-08-27.txt:02:55:40: <GregorR-L> http://www.codu.org/plof/
2006-08-27.txt:02:58:19: <GregorR-L> Well, "Plof attempts to be usable as a functional programming language, but without alienating imperative programmers."
2006-08-29.txt:00:11:47: <GregorR-W> http://www.codu.org/plof/
2006-08-29.txt:00:55:56: <Razor-X> So does Plof suck too?
2006-08-29.txt:00:56:14: <GregorR-W> Razor-X: Plof is designed to rectify my problems with P-languages ;)
2006-08-29.txt:16:49:59: <GregorR-W> So, I'm thinking of adding explicit security levels to Plof.  Internal/library functions would have a definition of their security level (perhaps 1-5) depending on trust.  So system, for example, would have a trust of 5, but if and println would have a trust of 1.  That way, you could (somewhat) safely run a remotely accessable interpreter, so long as you make sure to run it at low trust.
2006-08-31.txt:16:19:15: <GregorR-W> On an only vaguely-related subject, I made some improvements to Plof :P
2006-08-31.txt:16:27:35: <GregorR-W> nooga: http://www.codu.org/plof/
2006-08-31.txt:16:36:21: <GregorR-W> You'll note that plof2js is the only compiler ATM ;)
2006-08-31.txt:16:39:29: <ihope> So what's Plof have for arrays/lists?
2006-08-31.txt:16:44:25: <ihope> So Plof is dynamically typed?
2006-08-31.txt:16:49:27: <GregorR-W> Plof can be used functionally - that is, any function can be described as an expression instead of a series of statements.
2006-09-01.txt:16:57:03: <GregorR-W> Though }); has sort of become Plof's motto :P
2006-09-01.txt:20:23:42: <GregorR-W> OK foks: Should plof's new be recursive?
2006-09-02.txt:01:05:45: <GregorR-W> Plof Plof Plof.
2006-09-03.txt:01:59:33: <ifndef_GREGOR_H> To the degree that it was part of my inspiration to make Plof, a non-esoteric language.
2006-09-03.txt:02:01:00: * pikhq needs to look at Plof a bit. . .
2006-09-03.txt:02:01:20: <ifndef_GREGOR_H> http://www.codu.org/plof/
2006-09-03.txt:02:59:00: <Razor-X> I was gonna ask you what happened to Plof when you decided to make RawIRC.
2006-09-03.txt:03:00:35: <Razor-X> Sounds to me like you ran out of Plof-steam.
2006-09-03.txt:03:02:30: <ifndef_GREGOR_H> I actually need to upload my latest plof2js
2006-09-03.txt:03:13:54: <ifndef_GREGOR_H> Damn, there's a bug in plof2js' parser...
2006-10-13.txt:00:18:42: <GregorR-L> Go write an interpreter for http://www.codu.org/plof/
2006-10-13.txt:00:20:37: <GregorR-L> Plof and lisp aren't particularly similar.
2006-10-14.txt:01:16:56: <GregorR-L> I wrote an interpreter for Plof in D.
2006-10-14.txt:01:17:37: <ihope> Plof, eh?
2006-10-14.txt:01:17:48: <GregorR-L> http://www.codu.org/plof/
2006-10-14.txt:01:18:22: <GregorR-L> Ignore the plof2js on that web site, I broke it in transitioning to a new server and have been too lazy to fix it :P
2006-10-14.txt:04:39:25: <GregorR-L> println("Plof looks a lot like D in this case :P");
2006-10-17.txt:07:27:33: <GregorR-L> Plof + operator overloading.  Possible?
2006-10-18.txt:00:37:58: <GregorR-L> Plof! :P
2006-10-19.txt:00:14:12: <GregorR> http://www.codu.org/plof/ muahahaha :P
2006-10-21.txt:22:02:28: <Razor-X> Writing a Plof parser is something else.
2006-10-21.txt:22:02:34: <calamari> plof?
2006-10-21.txt:22:02:36: <Keymaker> plof?
2006-10-22.txt:05:01:10: <GregorR-L> I was absolutely shocked that somebody mentioned Plof - that's about the most recognition anybody in this channel will give to anybody else :P
2006-10-22.txt:05:08:02: <Sgeo> Plof?
2006-12-20.txt:04:02:38: <GregorR> require("stdio.plof"); stdio.StdOut.writeln("Plof lives!");
2006-12-20.txt:04:33:37: <GregorR> On an unrelated note, http://www.codu.org/plof/
2006-12-20.txt:04:46:06: <bsmntbombdood> GregorR, do you have an implementation of plof?
2006-12-20.txt:04:51:14: <GregorR> Want me to compile dplof for you?
2006-12-20.txt:04:54:19: <GregorR> http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-19.tar.gz
2006-12-20.txt:04:56:27: <GregorR> See module stdio.plof
2006-12-20.txt:05:15:37: <GregorR> OH ... I thought it was 'this', but I'm starting to think I may not have implemented that in dplof 8-X
2006-12-20.txt:05:28:10: <GregorR> http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-19-2.tar.gz
2006-12-20.txt:05:33:49: <GregorR> I think I inexplicably included some rampantly-incomplete core/*.plof files in that tarball, but no worries :P
2006-12-20.txt:05:59:30: <Sukoshi> So, is Plof a whole bunch of Flex/Bison?
2006-12-20.txt:18:03:48: <GregorR-W> I'm writing netio.plof :)
2006-12-20.txt:18:04:00: <GregorR-W> You could (at some point) write a Plof version :)
2006-12-20.txt:18:04:45: * pikhq should start learning Plof sometime
2006-12-20.txt:18:05:01: <pikhq> Maybe make a simple method of accessing C++ classes from Plof.
2006-12-20.txt:18:07:02: <GregorR-W> Plof is capable of accessing C via dlopen and friends.
2006-12-20.txt:18:07:41: * pikhq tries to find the Plof website
2006-12-20.txt:18:07:48: <GregorR-W> http://www.codu.org/plof/
2006-12-20.txt:18:07:58: <GregorR-W> If you want a binary of dplof I'll make one for you (presuming you don't have GDC)
2006-12-20.txt:18:14:43: <GregorR-W> http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-19-2
2006-12-20.txt:18:14:48: <GregorR-W> http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-19-2.tar.gz
2006-12-20.txt:18:46:06: <GregorR-W> pikhq: Presumably you got the dplof binary working? :P
2006-12-20.txt:18:49:44: <pikhq> It seems that Plof has sufficient capabilities to allow for a good deal of useful programming. . .
2006-12-20.txt:18:50:15: <GregorR-W> I'd like to make a "standard" Plof GUI interface.
2006-12-20.txt:18:55:01: <pikhq> (netio.plof)
2006-12-20.txt:18:59:19: <pikhq> You know, that sort of *does* look weird in Plof.
2006-12-20.txt:20:20:30: <GregorR-W> Sukoshi: Yes, functions are first-class data types, Plof is intended to be a hybrid of functional and imperative.
2006-12-20.txt:20:22:33: <GregorR-W> The basic syntactic structure of Plof and lisp are too different to compare. eg, exactly what Sukoshi just said.
2006-12-20.txt:20:38:10: <bsmntbombdood> "Unlike (most of) the other P-languages, Plof attempts to be usable as a functional programming language"
2006-12-20.txt:21:42:45: <GregorR-W> In case anybody's interested in Plof with the new changes, http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-20.tar.gz
2006-12-20.txt:21:44:56: <bsmntbombdood> Error: AssertError Failure plof/runtime.d(722) 
2006-12-20.txt:22:44:49: <bsmntbombdood> Asztal: Error: AssertError Failure plof/parser.d(122)
2006-12-20.txt:23:02:56: <GregorR-W> Plof tokenizer in Plof 4tw :)
2006-12-20.txt:23:09:30: <GreaseMonkey> hashEsoteric@()=+{if({GregorR~.CheckStatus("BuildingPlofCompiler");}{GreaseMonkey~.Act("BuildTomatoCompiler")});};
2006-12-21.txt:03:48:42: <GregorR-L> Zomg Plof! :)
2006-12-21.txt:06:42:54: <GregorR-L> bsmntbombdood: I've improved dplof's error output.
2006-12-21.txt:06:48:46: <GregorR-L> bsmntbombdood: http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-20-2.tar.gz if you care
2006-12-21.txt:22:33:27: <GregorR-W> var = a [ main = { println("Plof rocks!"); } ]; a.main();
2006-12-21.txt:22:33:37: <GregorR-W> var a = [ main = { println("Plof rocks!"); } ]; a.main();
2006-12-22.txt:00:59:25: <GregorR-W> I think it's time for me to write plofplof ...
2006-12-22.txt:01:11:35: <GregorR-W> And replace them with Plof!
2006-12-22.txt:06:33:47: * GregorR now has plofbf :)
2006-12-22.txt:06:39:30: <GregorR> I'll stick in in the dplof tarball :P
2006-12-22.txt:06:43:43: <GreaseMonkey> wait, where are the plof docs again?
2006-12-22.txt:06:44:14: <GregorR> http://www.codu.org/plof/
2006-12-22.txt:06:44:27: <GregorR> plofbf is in examples/ here: http://www.codu.org/plof/dplof-x86-gnuWlinux-2006-12-21.tar.gz
2006-12-22.txt:06:46:15: <GreaseMonkey> weird, plof looks quite like tomato
2006-12-22.txt:17:49:27: <GregorR> Weeeh, Plof!
2006-12-22.txt:17:54:35: <Sukoshi> I need to look at Plof some time.
2006-12-22.txt:17:54:53: <Sukoshi> But right now, I'm deferring all my schoolwork for coding work, so Plof will be more of a distraction.
2006-12-22.txt:19:01:31: <Sukoshi> Oh GregorR, does Plof have lexical or dynamic bindings, or both?
2006-12-22.txt:19:03:21: <Sukoshi> Is the object system of Plof message passing?
2006-12-22.txt:19:05:00: <GregorR> bsmntbombdood: dplof is not only a simple interpreter, but a ridiculously terrible one :)
2006-12-24.txt:01:38:55: <pikhq> GregorR: In Plof, your "for" loop semantics are really different from C's. . .
2006-12-24.txt:02:40:45: <pikhq> Do it in Plof.
2006-12-24.txt:02:41:07: <pikhq> (Plof is in bad need of Esome)
2006-12-24.txt:05:34:53: <GregorR> Anybody want to help me improve Plof's arrays?
2006-12-24.txt:23:49:21: <GregorR> How about helping me improve Plof's array syntax.
2006-12-24.txt:23:50:37: <bsmntbombdood> s/plogs/Plof/
2006-12-24.txt:23:55:12: <bsmntbombdood> GregorR: So, you have to declare them like any other variable in plof...
2006-12-26.txt:23:15:16: <pikhq> while(1, {println("I love Plof!");});
2006-12-27.txt:01:52:16: <pikhq> GregorR: Like the changes in the current Plof build.
2006-12-27.txt:20:03:56: <GregorR> CakeProphet: Plof
2006-12-27.txt:20:07:40: <GregorR> "Plof" is a cool name :P
2006-12-30.txt:04:35:21: <GregorR> Plof's only stack is a stack of hashes (the scope)
2006-12-31.txt:01:07:10: * GregorR hands CakeProphet Plof.
2006-12-31.txt:01:07:29: <GregorR> http://www.codu.org/plof/
2006-12-31.txt:01:09:09: <CakeProphet> Plof basically looks like... C.
2006-12-31.txt:01:09:19: <GregorR> CakeProphet: Plof isn't esoteric by nature :P
2006-12-31.txt:20:04:34: <bsmntbombdood> GregorR: Fix Plof
2006-12-31.txt:20:15:04: <GregorR> OK, new Plof tarball available.
2006-12-31.txt:20:38:19: <GregorR> Plof is pretty minimal (ha-HAH)
2007-02-12.txt:05:13:36: <_D6Gregor1RFeZi> Anybody want to help me redesign Plof?
2007-02-12.txt:05:16:34: <GreaseMonkey> weird, plof looks kinda like tomato
2007-02-12.txt:05:16:48: <pikhq> Plof kicks ass.
2007-02-12.txt:05:17:26: * pikhq contemplates a Plofish way to do that. . .
2007-02-12.txt:05:17:35: <_D6Gregor1RFeZi> I think I need some kind of nomenclature to differentiate them, but that would increase the confusion involved in writing Plof by quite a bit :(
2007-02-12.txt:05:19:16: <GreaseMonkey> that is quite weird how plof has its similarities to tomato
2007-02-12.txt:05:19:36: <GreaseMonkey> i admit plof was made first
2007-02-12.txt:05:29:22: <_D6Gregor1RFeZi> e.g. any language which uses functions like Plof does will need to have a complex return system.
2007-02-12.txt:22:31:07: <oerjan> (the last in the context of your plof question)
2007-02-12.txt:22:33:53: <oerjan> does plof have lexical scoping?
2007-03-15.txt:22:41:24: <GregorR> Plof has a lot of });
2007-03-29.txt:00:39:03: * GregorR considers rererererecreating Plof.
2007-03-30.txt:00:00:18: <GregorR> Plof2 is coming along nicely :)
2007-03-30.txt:00:00:56: <oklopol> i read about plof
2007-03-30.txt:00:01:17: <GregorR> I made some fairly major changes to areas in Plof1 that bugged me.
2007-03-30.txt:00:08:36: <pikhq> So, Plof2 is basically a redesign of Plof, simply due to limitations of the basic concepts of Plof1
2007-03-30.txt:09:00:48: <GreaseMonkey> plof again?
2007-03-30.txt:09:42:19: <oklopol> ":[", "];" plof :<
2007-03-30.txt:09:44:57: <GregorR> ^(I'm Plof and I frown :[ )
2007-03-30.txt:09:45:21: <oklopol> !ul (I'm Plof and I frown :[ )^
2007-03-30.txt:09:46:38: <oklopol> !ul (I'm Plof and I frown :[ )S
2007-03-30.txt:09:46:40: <EgoBot> I'm Plof and I frown :[ 
2007-03-30.txt:09:46:53: <oklopol> !ul (I'm Plof and I frown :[ )aS
2007-03-30.txt:09:46:56: <EgoBot> (I'm Plof and I frown :[ )
2007-03-30.txt:09:47:11: <oklopol> !ul (I'm Plof and I frown :[ ):aSS
2007-03-30.txt:09:47:14: <EgoBot> (I'm Plof and I frown :[ )I'm Plof and I frown :[ 
2007-04-01.txt:06:38:26: <GregorR> Pikhq: Care to give me an opinion on something I'm mulling over for Plof2?
2007-04-01.txt:06:46:26: <GregorR> Well, if is a function in the Plof standard namespace which is provided by the compiler ... I'm just trying to reduce the number of those. I suppose nobody really cares except me, so maybe I need to not do that ^^
2007-04-01.txt:06:48:05: <Pikhq> I *like* being able to see the interface in stdlib.plof.
2007-04-01.txt:06:49:33: <GregorR> bsmntbombdood: Well, there are two operators that it makes NO sense to overload with how Plof works: assignment and object combination.
2007-04-02.txt:04:02:49: <GregorR> [In Plof]
2007-04-02.txt:04:16:49: <oerjan> i understand plof is dynamically typed, so the functions would have to check argument types and backtrack to the next function on failure.
2007-04-02.txt:04:17:34: <GregorR> oerjan: Plof is dynamically typed with some static typing operators. There is such an operator in function signatures, which enforces that the function is called with the proper arguments.
2007-04-02.txt:08:14:02: <GregorR> So, it's like Plof X-D
2007-04-02.txt:19:58:17: <GregorR> Changes for Plof2: 1) Ability to call arrays of functions for overloading, 2) null operator for object combination, 3) Remove ternary comparison and re-add builtin if et cetera, 4) Change return rules: If a value returned from a thin function is actually used (e.g. on the right side of an assignment), it does not continue to fall through. This will allow if() and pals to be used in both the imperative sense and the functional sense.
2007-04-03.txt:06:14:06: <GregorR> To anybody interested, #plof 
2007-04-03.txt:11:54:58: <oerjan> (in plof)
2007-04-03.txt:13:31:00: <nooga_> plof
2007-04-04.txt:03:12:39: <GregorR> [You don't have #plof on autojoin :( :P]
2007-04-05.txt:01:29:30: <GregorR> My head is melting over my attempts to make sensible reference semantics for Plof :(
2007-04-05.txt:01:43:30: <GregorR> bsmntbombdood: I can't overload "=" because of the very nature of Plof.
2007-04-05.txt:01:45:10: <GregorR> ihope: Join #plof
2007-04-05.txt:01:49:33: <ihope> #plof!
2007-04-05.txt:02:18:41: <Pikhq> Well, we've already got the child of Smalltalk and C++ going in #plof. . . ;)
2007-04-05.txt:05:23:54: <CakeProphet> er... wrong channel... but we're all pretty much over on #plof too
2007-04-05.txt:06:23:37: <GreaseMonkey> i think it's the same with plof
2007-04-05.txt:06:24:04: <GreaseMonkey> for some weird-ass reason, stuff from plof seems to have seeped into tomato which potato is based on
2007-04-06.txt:07:14:51: <GregorR> Now, everybody go talk about how whootsy http://www.codu.org/plof/ is :)
2007-04-06.txt:07:23:15: <GregorR> To Plof!
2007-04-06.txt:07:23:30: <Figs> Plof?
2007-04-06.txt:07:23:35: <GregorR> http://www.codu.org/plof/
2007-04-06.txt:07:24:52: <Figs> PLOFF!
2007-04-06.txt:07:28:02: <bsmntbombdood> std.plof
2007-04-06.txt:07:28:36: <GregorR> That was from the leading edge of Plof1.
2007-04-08.txt:02:28:04: <Pikhq> I've grown fond of Plof. . .
2007-04-08.txt:02:28:19: <Sukoshi> I'm waiting for Plof to mature :)
2007-04-08.txt:02:28:33: <Sukoshi> Is Plof compiled?
2007-04-11.txt:00:49:19: <GregorR> http://www.codu.org/plof/ :-P
2007-04-11.txt:01:40:18: <GreaseMonkey> i love the way you define classes in plof
2007-04-11.txt:01:41:50: <GreaseMonkey> when talking about plof
2007-04-11.txt:01:47:14: <Pikhq> GregorR: I'm obviously used to Plof 1. ;)
2007-04-11.txt:01:47:29: <GregorR> Plof supports a , operator :P
2007-04-11.txt:01:49:45: <Pikhq> I don't think a tuple is even a datatype in Plof.
2007-04-11.txt:03:33:23: * GregorR <3 Plof
2007-04-11.txt:03:33:31: <GregorR> Time to write Plofmacs :P
2007-04-11.txt:04:57:01: <GregorR> Plof2 8-D
2007-04-11.txt:04:57:57: <GreaseMonkey> Plof2 8=D
2007-04-25.txt:01:52:22: <GregorR> pikhq: Do you think I should remove the special scope-reassignment of functions with assignment in Plof?
2007-04-25.txt: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.
2007-04-25.txt:02:46:20: <GregorR> But, as a functional language, Plof is Ridiculously Impure (TM).
2007-04-25.txt:02:48:01: <SevenInchBread> not sure if it would work well in plof
2007-04-25.txt:02:49:08: <SevenInchBread> which is something that is done a lot in plof
2007-04-25.txt:02:49:21: <GregorR> Plof has no classes.
2007-04-25.txt: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)
2007-04-25.txt:03:02:34: <GregorR> It is hackish, but it's not as bad as what I had in Plof1 :P
2007-04-27.txt:21:58:28: <GregorR> pikhq: My improved Plof interpreter works now :)
2007-04-28.txt:00:50:03: <GregorR> My new DPlof interpreter can run PlofPlof properly!
2007-04-28.txt:00:51:54: <pikhq_> PlofPlof?
2007-04-28.txt:00:54:14: <GregorR> pikhq_: My intention is to use DPlof just to get Plof (the one in Plof) working. Then I'll make Plof target C (as well as interpretation), and bingo, CPlof.
2007-04-28.txt:00:54:32: <pikhq_> What does PlofPlof compile to now?
2007-04-28.txt:00:55:02: <lament> compiles to plof, obviously
2007-04-28.txt:00:55:19: <GregorR> I had to leave it for a while because DPlof couldn't run it X-P
2007-04-28.txt:00:55:20: <pikhq_> I assume you wouldn't mind my help in PlofPlof?
2007-04-28.txt:00:56:12: <GregorR> DPlof is damn slow, but like I said, it's temporary.
2007-04-28.txt:01:04:55: <GregorR> ... this is building dplof?
2007-04-28.txt:01:07:53: <pikhq_> You think I could get a binary tarball of Dplof?
2007-04-28.txt:01:08:01: <bsmntbombdood> GregorR> pikhq_: My intention is to use DPlof just to get Plof (the one in Plof) working. Then I'll make Plof target C (as well as interpretation), and bingo, CPlof.
2007-04-28.txt:01:08:58: <pikhq_> Even Brainfuck can self-host. Why not Plof?
2007-04-28.txt:01:09:48: <pikhq_> And I bet that Plof'd get more popularity if Dplof weren't a build requirement.
2007-04-28.txt:01:09:54: <GregorR> bsmntbombdood: The fact that that gives me Plof in C for free is just a side-effect.
2007-04-28.txt:01:09:58: <bsmntbombdood> so just write a plof->c compiler
2007-04-28.txt:01:10:10: <pikhq_> It just happens to be in Plof.
2007-04-28.txt:01:10:11: <bsmntbombdood> without a dplof of plofplof
2007-04-28.txt:01:11:13: <pikhq_> Dplof will be abandoned once Plof works.
2007-04-28.txt:01:11:30: <GregorR> pikhq_: http://www.codu.org/plof.tar.gz
2007-04-28.txt:01:11:38: <GregorR> pikhq_: http://www.codu.org/dplof.tar.gz
2007-04-28.txt:01:13:09: <GregorR> Disclaimer: dplof may have (and probably does have) obscure bugs :)
2007-04-28.txt:01:14:15: <lament> plof looks pretty boring
2007-04-28.txt:01:18:43: <pikhq_> Moral of the story: Dplof and x86_64 don't mix.
2007-04-28.txt:01:19:02: <pikhq_> CPlof should be easier to get to mix, though.
2007-04-28.txt:01:43:58: <pikhq> I'd *like* to see a better way for Plof to access C functions than the current method. . . I assume that's planned after Plof runs?
2007-04-28.txt:01:44:05: <pikhq> cPlof, even.
2007-04-28.txt:01:46:39: <pikhq> Seems that C++ could possibly behave better with Plof.
2007-04-28.txt:01:47:44: <pikhq> I *think* the best way to do it would probably involve a Plof<->C API, so the Plof interpreter or compiler could load libraries conforming to that API.
2007-04-28.txt:01:50:54: <GregorR> I think the name mangling is a non-issue. But otherwise, yeah, it would make sense if the C functions basically were Plof functions which happened to have native code.
2007-04-28.txt:01:51:39: <pikhq> It's an easy solution, which allows for consistency with Plof.
2007-04-28.txt:01:51:54: <pikhq> Doesn't work well for Dplof, methinks, though.
2007-04-28.txt:01:52:14: <GregorR> It'd work fine for DPlof - unions and structs in D are exactly equivalent to their C versions.
2007-04-28.txt:03:07:52: <pikhq> Plof's going to become self-hosting soon as Gregor and I bother.
2007-04-28.txt:03:09:50: <pikhq> No, bootstrapping it with DPlof.
2007-04-28.txt:04:28:54: <GregorR> Arrrgh, I thought dplof was broken in some horrible way - as it turns out, indexing a linearly linked list is not efficient :P
2007-04-28.txt:04:30:23: <GregorR> No, the problem is that dplof crashed when I was running PlofPlof.
2007-04-28.txt:04:30:33: <GregorR> zorkplik: Plof is not esoteric.
2007-04-28.txt:04:30:48: <zorkplik> oh, plof.
2007-04-28.txt:04:31:13: <pikhq> Plof is a serious project of Gregor's. ;)
2007-04-28.txt:05:03:50: * GregorR wonders what other basic container types Plof needs....
2007-04-28.txt:05:33:56: <GregorR> Current collections in the Plof core: AArray, Array, LazyCollection (every item is generated from a function), List, Range, Set.
2007-04-28.txt:05:43:53: <GregorR> Plof is anything but purely functional :)
2007-04-28.txt:05:47:21: <GregorR> Now that I actually have Plof at a very usable place, I don't know what to do next X-P
2007-04-28.txt:05:48:49: <GregorR> Yeah, but that's just it - the only program I need to write right now is PlofPlof, and I want to hold off on that until my head stops spinning.
2007-04-28.txt:10:07:51: <GregorR> oklopol: Depends ... do you have any interest in Plof? :P
2007-04-28.txt:23:32:39: <GregorR> Anybody want to write a Plof CGI module? :)
2007-04-30.txt:03:21:37: * GregorR has begun work on his Plof->C compiler :)
2007-04-30.txt:21:32:36: <GregorR> DPlof's parser doesn't use a lookahead
2007-05-01.txt:13:25:48: <pikhq> Plof.
2007-05-05.txt:00:57:06: <pikhq> GregorR: You mind me asking how CPlof goes?
2007-05-05.txt:02:51:27: <GregorR> Pikhq: It compiles Plof to C, but I haven't finished the runtime library.
2007-05-05.txt:02:51:36: <GregorR> Pikhq: A few simple things work (such as the Plof program '0')
2007-05-05.txt:02:53:34: <Pikhq> GregorR: Think you could shove a copy of Cplof into my home dir or something?
2007-05-05.txt:02:57:45: <GregorR> It's the "plof" darcs repo.
2007-05-05.txt:02:57:53: <GregorR> The same code base will be both cplofc and plofplof.
2007-05-05.txt:03:00:10: * Pikhq wonders why PlofParameters params is commented out. . .
2007-05-05.txt:03:09:57: * Pikhq needs to see what the hell a PlofThing array would look like to be sure what would and wouldn't be useful. . .
2007-05-05.txt:03:12:06: <Pikhq> GregorR: Is an array of PlofThings terminated by a PlofThing with PlofThing.type == TYPE_VOID?
2007-05-05.txt:03:14:05: <GregorR> Pikhq: By my CPlofC design, yuh.
2007-05-05.txt:03:33:52: <Pikhq> GregorR: You know what'd be *really* nice? A *generic* PlofThing constructor. . . Taking in a PlofThing and returning a copy of said PlofThing.
2007-05-05.txt:03:34:24: <Pikhq> It'd simplify what I'm *thinking* would be best for the PlofArray constructor. . .
2007-05-05.txt:04:27:10: <GregorR> Pikhq: Feel free to make the PlofThing duplicator.
2007-05-05.txt:04:27:24: <GregorR> Pikhq: What's wrong with the indentation style in plof.c? :(
2007-05-05.txt:04:38:54: <Pikhq> Mmkay; got it returning plofStub();
2007-05-05.txt:04:40:06: <Pikhq> I've got plofNewPlofThingGeneric(PlofThing *pthng); written. . .
2007-05-05.txt:04:46:13: <Pikhq> And I think I've got plofNewPlofThingArray(PlofArray *a); written.
2007-05-05.txt:04:49:14: * Pikhq will assume, at least for a moment, that you appreciate having someone else do something on Plof. :p
2007-05-05.txt:04:51:12: <Pikhq> I've probably done the array constructor in a bit of an annoying fashion, but that's largely a side effect of having to copy each member of the PlofArray by hand. . .
2007-05-05.txt:04:55:03: <Pikhq> On your box, ~pikhq/plof.c contains my changes.
2007-05-18.txt:03:13:00: <Pikhq> Yeah. Why're you not working on Plof (I keed, I keed)? :p
2007-05-18.txt:03:16:58: * Pikhq should try and get PlofBrainfuck to work. . .
2007-05-18.txt:04:47:09: <Pikhq> PlofBrainfuck, so I don't have to get my attempt to work. :p
2007-05-25.txt:21:23:30: <Pikhq> Gregor, why the Plof errors on stdout instead of stderr?
2007-05-26.txt:01:56:12: <oklopol> hehe, i have lisp-like quotes, but for a different reason, plof-like lambda specifiers (: and .), but for a different reason :P
2007-05-26.txt:02:03:05: <Pikhq> TO THE PLOF FOR YE!
2007-05-26.txt:02:05:30: <oklopol> i haven't yet gotten acquinted (<- fix my word) with plof
2007-05-26.txt:02:05:59: <oklopol> is there a graphics library for plof? :P
2007-05-26.txt:02:07:34: <oklopol> does plof have c-import?
2007-05-26.txt:02:10:52: <GregorR> Which, in a language is inefficient as Plof, is a nonissue :P
2007-05-28.txt:05:23:03: <oklopol> AND WHY ARE FUNCTIONS DEFINED BY ASSIGNING LAMBDAS TO VARIABLES IN PLOF AND K... THAT WAS ORIGINALLY MY IDEA, THEY STOLE IT
2007-05-28.txt:05:24:02: <Pikhq> oklopol: Plof predates your language.
2007-05-28.txt:05:24:30: <oklopol> K predates plof by about 10 years
2007-05-28.txt:05:26:12: <oklopol> plus, i wouldn't count on plof predating my language
2007-05-31.txt:22:17:28: <oerjan> or D, or plof
2007-06-01.txt:02:50:06: <Pikhq> GregorR-L: Obviously what you need is the very, very powerful "Plof reference counting" algorithm.
2007-06-07.txt:05:47:14: <pikhq> Gregor, I was just randomly running strings on cplofc. . . And I'm wondering: how the *hell* did "Hello, world!" get into there?
2007-06-07.txt:05:54:10: <pikhq> . . . Oh, shit. Dplof is written in D, and Gregor is a major D developer. . .
2007-06-07.txt:06:58:33: <GregorR-L> pikhq: And that's from some tests compiled into fileio.plof
2007-06-07.txt:07:37:53: <pikhq> Invent Plof 0.1
2007-07-04.txt:21:17:57: <Sukoshi> I have to say, I prefer Io over Plof, GregorR.
2007-07-04.txt:21:41:27: <pikhq> Sukoshi: I kind of like the general *flavor* of Plof, though.
2007-07-08.txt:02:34:15: <pikhq> Brilliant, but why isn't it in Plof?
2007-07-14.txt:05:13:58: <pikhq> Plof == :)
2007-07-15.txt:23:20:10: <pikhq> Call it Plof.
2007-07-15.txt:23:25:15: <pikhq> I'd say Plof is, well, functional programming for a C coder.
[too many lines; stopping]