< 1201565090 0 :puzzlet!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201565102 0 :puzzlet!n=puzzlet@147.46.241.160 JOIN :#esoteric < 1201565238 0 :Corun_!unknown@unknown.invalid QUIT :"This computer has gone to sleep" < 1201565298 0 :pgimeno!unknown@unknown.invalid PART #esoteric :? < 1201565373 0 :Corun!n=Corun@halls-129-31-72-183.hor.ic.ac.uk JOIN :#esoteric < 1201566156 0 :RockerMONO[enfr]!unknown@unknown.invalid NICK :RockerMONO < 1201566191 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1201566700 0 :immibis!n=immibis@125-236-142-87.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1201567480 0 :dbc!unknown@unknown.invalid QUIT :Client Quit < 1201568935 0 :ehird_!n=ehird@user-514fb24f.l2.c4.dsl.pol.co.uk JOIN :#esoteric < 1201568970 0 :ehird!unknown@unknown.invalid PART #esoteric :? < 1201568984 0 :ehird_!unknown@unknown.invalid NICK :ehird < 1201569455 0 :Corun!unknown@unknown.invalid QUIT :"This computer has gone to sleep" < 1201569988 0 :immibis_!n=immibis@125-236-142-87.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1201570003 0 :immibis_!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201570670 0 :ehird!unknown@unknown.invalid QUIT :"This computer has gone to sleep" < 1201573197 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :ACTION made an irc bot in brainfuck (using my interpreter that has networking) that can parse brainfuck < 1201573566 0 :immibis!unknown@unknown.invalid PART #esoteric :? < 1201574250 0 :RockerMONO!unknown@unknown.invalid NICK :Rocker[box] < 1201577080 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :You shouldn't need an interpreter with networking, just netcat :P < 1201577100 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :That being said: Really? An IRC bot written IN BF that INTERPRETS BF? That's pretty cool. < 1201577177 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Get it on. < 1201577255 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :This isn't relevant, but it's insanely awesome: http://www.nongnu.org/sps/ < 1201577287 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Well aware. < 1201577311 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Oh. < 1201577316 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :You did more stuff to it. < 1201577319 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :That's damned awesome. < 1201577421 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I didn't just do more to it, I rewrote it from scratch as a FUSE filesystem utilizing Debian packages. < 1201577548 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Damn. < 1201578502 0 :Insane!n=ltkde@unaffiliated/insane JOIN :#esoteric < 1201578519 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Somebody do me a favor and randomly link me to a fun language < 1201578544 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ERROR: I DON'T WANNA. < 1201578556 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Ooooooh < 1201578563 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Let's invent ERRORCODE < 1201578577 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :What, where everything is a Kimian quine? < 1201578577 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :you program in error messages < 1201578607 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :What's a kimian quine? < 1201578653 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :A quine which depends upon the error reporting facilities of a language. < 1201578671 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :In some BF interpreters, "Mismatched ]." is a Kimian quine. < 1201578672 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :mk < 1201579842 0 :adu!n=andrew@pool-71-178-9-246.washdc.fios.verizon.net JOIN :#esoteric < 1201580151 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :could somebody explain a "Kimian quine" to me? I've heard this obscure fact, but I could never find a more detailed explanation < 1201580174 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :like, in detail? < 1201580195 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :is the idea that mismatched brackets will output an error message containing "]" somehow? < 1201580354 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :and Insane- your idea sounds intriguing. Like a language in which you "program" to some extent by purposely producing various types of errors? < 1201580390 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :You'd probably want a nearly TC base language with some key features missing, and then use bizarre side effects of error messages to fill in the gaps < 1201580846 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Hmm < 1201580870 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Maybe something like dividing by zero to output memory < 1201581448 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :could work < 1201581470 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :if it was interpreted in some fashion you could use nullpointer exceptions and array index out of bounds violations < 1201581524 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :there are a number of nonfatal things, like conversions that lose precision, that could fail predictably to provide rudimentary math or something < 1201581801 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Basically, you create a program whose *error messages* are the program. < 1201581993 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Maybe you can simply "emulate" error messages < 1201582010 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :counter from 1 to 10: i = 1; LOOP { i = i + 1; peek(0); 1/(0-i); }, EXCEPT (DivZero) { BREAK; }, EXCEPT (NullRead) { ErrStr = str(i) + chr(10); COMPLAIN; CONTINUE; }; < 1201582019 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :eg. instead of really dividing by 0 and catching an error, you could pretend to < 1201582023 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :actually... < 1201582031 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :counter from 1 to 10: i = 1; LOOP { i = i + 1; peek(0); 1/(0-i); }, EXCEPT (DivZero) { BREAK; }, EXCEPT (NullRead) { ErrStr[NullRead] = str(i) + chr(10); COMPLAIN; CONTINUE; }; < 1201582154 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :DO { 1/0; }, EXCEPT (DivZero) { DivZero = "Hello World!" + chr(10); COMPLAIN; CONTINUE; }; < 1201582187 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :this could tie into the idea we had earlier about a language where all logic, variables and flow control was a twisted mass of exception throwing and catching < 1201582204 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :exceptions themselves formed the mechanism for storing variables < 1201582222 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :and the potential for conditionals is obvious < 1201582252 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :and with some kinda nasty object oriented stuff it was possible to do recursion with them < 1201582258 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I forget all the details < 1201582279 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :but we can call the language "DieHard" or something < 1201582298 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201582314 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :I'm still working on writing an irc bot in NetBrainFuck < 1201582328 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :NetBrainFuck provides 4 more instructions < 1201582329 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :or name it after the big iron OS "NonStop", legendary for it's reliablility < 1201582338 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :connecting using data from memory, reading, writing, d < 1201582342 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :*disconnecting < 1201582351 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :NetBrainFuck? shouldn't it be "ClusterFuck"? < 1201582362 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Heh. Maybe < 1201582421 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :how about FuckThis? < 1201582483 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :FuckItAll < 1201583256 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Let's make SLOCODE where every instruction takes a while, forcing programmers to write efficient code or wait forever < 1201583266 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :hm easy < 1201583284 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :s/*/*sleep(2000);/g < 1201583498 0 :Insane!unknown@unknown.invalid QUIT :Remote closed the connection < 1201584818 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :no, SLOCODE should turn conventions of cost and speed on their heads < 1201584833 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :what should be slow will be fast and vice versa < 1201584862 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :we could essentially accomplish this with a hideously complex "optimizer" routine < 1201585130 0 :adu!unknown@unknown.invalid PART #esoteric :? < 1201585501 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i read somewhere that any universal lang can simulate any other efficiently, meaning running in polynomic time compared to the original prog in the other language, anyone know if this is true? < 1201585537 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :was just thinking about ais's O(2^2^n) simulation of a utm, unless i remember that wrong too < 1201585795 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, it at least seems plausible < 1201585834 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that is a bit hard to google : D < 1201585914 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I now challenge you to write a lisp (or scheme) interpreter for the Z1. < 1201586082 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Z1? :) < 1201586096 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i didn't read the paper. < 1201586116 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*couldn't < 1201586215 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :e.g. v++ goes to v += 0xFF; for(i=0;i<0xFF;i++) v--; < 1201586219 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i was just thinking, in case that polynomic time is *not* true, might be interesting to try and make the slowest language ever < 1201586299 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the Z1 was one of the first computers, created by Konrad Zuse. < 1201586304 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if there's no polynomic bound, you can probably make a language, in theory, that can actually be parametrized to be infinitely slow < 1201586323 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh, right, i was assuming that had to do with the proof :D < 1201586467 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :what i meant was a limit of infinite running time < 1201586505 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :when growing a param of the language < 1201586565 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :something like 2^2^2^...^n where you can choose the number of 2's by slightly modifying the language < 1201586694 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :since i don't think you can assume any optimization when calculating that, doesn't seem impossible really < 1201588400 0 :calamari!n=calamari@ip24-255-58-134.tc.ph.cox.net JOIN :#esoteric < 1201589214 0 :calamari!unknown@unknown.invalid QUIT :"Leaving" < 1201592173 0 :puzzlet!unknown@unknown.invalid QUIT :Remote closed the connection < 1201592181 0 :puzzlet!n=puzzlet@147.46.241.160 JOIN :#esoteric < 1201593599 0 :clog!unknown@unknown.invalid QUIT :ended < 1201593600 0 :clog!unknown@unknown.invalid JOIN :#esoteric < 1201598370 0 :GreaseMonkey!unknown@unknown.invalid QUIT :"night" < 1201599366 0 :puzzlet!unknown@unknown.invalid QUIT :Remote closed the connection < 1201599374 0 :puzzlet!n=puzzlet@147.46.241.160 JOIN :#esoteric < 1201600039 0 :sebbu!unknown@unknown.invalid QUIT :"bye" < 1201609398 0 :ehird!n=ehird@user-514fb24f.l2.c4.dsl.pol.co.uk JOIN :#esoteric < 1201610317 0 :ehird!unknown@unknown.invalid TOPIC #esoteric :Continuing the tradition of me changing the topic when I get up, the topic is now "Conti < 1201611903 0 :jix!i=chaos@bytefight.org JOIN :#esoteric < 1201613167 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hello jix < 1201614345 0 :helios24!i=chaos@bytefight.org JOIN :#esoteric < 1201615184 0 :Tritonio_!n=Tritonio@150.140.226.8 JOIN :#esoteric < 1201615285 0 :sebbu!n=sebbu@ADijon-152-1-48-85.w83-194.abo.wanadoo.fr JOIN :#esoteric < 1201615525 0 :Hiato!n=Hiato@dsl-245-57-28.telkomadsl.co.za JOIN :#esoteric < 1201615548 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Wassup < 1201616334 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :the sky < 1201616351 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :I hoped as much < 1201616363 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I am trying to pervert Hofstadter's "GOD Over Djinn" into an esolang name. < 1201616404 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Hrmm... GOD Over Gin ? Naah, nevermind.... < 1201616421 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :He already made that joke, in the same story. < 1201616438 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Oh well.. I tried ;) < 1201616459 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :The characters (The Tortoise and Achilles) had entered an M.C. Escher painting using pushing & popping tonics (used to explain call stacks). < 1201616486 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :That was where they met the infinite chain of Djinn (Djii?), collectively referred to as the recursive acronym "GOD Over Djinn". < 1201616495 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :The dialogue, of course, was called "Djinn and Tonic". < 1201616546 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Ah, I see. Wel,, I'm out of suggestions (yes, after but one), but I'll keep thinking about it - if that helps :) < 1201616579 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::-P < 1201616581 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Thanks, I guess. < 1201617947 0 :jix!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201617984 0 :jix!i=chaos@bytefight.org JOIN :#esoteric < 1201618797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Someone name my concatentative esolang like Joy :P < 1201619165 0 :Elion!n=elionelf@dooku.satgate.net JOIN :#esoteric < 1201619971 0 :Elion!unknown@unknown.invalid QUIT :Remote closed the connection < 1201619990 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::| < 1201620686 0 :Tritonio_!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out) < 1201620714 0 :Tritonio_!n=Tritonio@150.140.226.176 JOIN :#esoteric < 1201621034 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Hmm < 1201621036 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Who is alive right now? < 1201621310 0 :Asztal!unknown@unknown.invalid QUIT :"not me" < 1201621390 0 :Insane!n=ltkde@unaffiliated/insane JOIN :#esoteric < 1201621392 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Nobody? < 1201621405 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Internet connectivity? check < 1201621472 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :check! :)))) < 1201621480 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hehe < 1201621503 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :who wants to talk about a concatentative esolang similar to Joy and Cat? *crickets chirp* oh. nobody? :( < 1201621559 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Joy and Cat?.................... < 1201621567 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Sounds like a disease < 1201622066 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201622078 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :google 'joy programming language' < 1201622079 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ditto for cat < 1201622139 0 :Insane_!n=ltkde@dslb-088-065-025-033.pools.arcor-ip.net JOIN :#esoteric < 1201622149 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :they are both very interesting < 1201622201 0 :Insane!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201622240 0 :Insane_!unknown@unknown.invalid NICK :Insane < 1201622258 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :IKsn't a cat a pĆ¼rogr < 1201622264 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :*program that outputs input? < 1201622268 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :*Isn't < 1201622274 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes, but it's also a programming language... < 1201622276 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :sheesh! < 1201622277 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :I'm gonna smack his lappy keyboard... < 1201622283 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :first and foremost, a cat is an animal < 1201622284 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :*this < 1201622288 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it doens't have to be only one program! < 1201622289 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Eh?? < 1201622297 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :What's an animal? < 1201622325 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :English isn't your native language, is it. < 1201622341 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Yes it is :P < 1201622349 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Just joking, I know what an animal is < 1201622354 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201622384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Insane: You know Forth? < 1201622403 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Well, Joy is like a functional (not in the sense of 'works', of course) Forth. < 1201622414 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Cat is like a functional, statically-typed (!) Forth, < 1201622416 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :. < 1201622501 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Hmm < 1201622505 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :What's Forth? ^^ < 1201622534 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I don't think you're the best person to talk about this with... < 1201622538 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Right < 1201622544 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: You know Forth, don't you :P < 1201622569 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :The only esoteric languages I know are brainfuck, NetBrainFuck and 1337 < 1201622613 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Insane: Forth,Joy,Cat aren't esoteric. < 1201622620 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :Ooh? < 1201622626 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :interesting < 1201622629 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Well. < 1201622632 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird: i know it's a stack-based language. < 1201622638 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :You could call them esoteric. But people use Forth for real-world apps, all the time < 1201622641 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Mainly in embedded systems. < 1201622642 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and that it's old and famous < 1201622647 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Cat is a mainly-research-and-teaching language. < 1201622659 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Joy is a 'ooh, what would happen if we...' language made by a philosophy professor guy < 1201622666 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: well, you know stack based languages. < 1201622671 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1201622675 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, concatentative languages, to be precise. < 1201622698 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i.e. < 1201622727 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :for all A,B in P. concat(A,B) == compose(A,B) where P = programs in language L < 1201622732 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :==> language L is concatentative < 1201622743 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and unless it's a computationally useless language you achive that with a stack. < 1201622747 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: there, have a formal definition < 1201622764 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, thanks for that i guess :) < 1201622784 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: know Joy? < 1201622805 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :once again i just know some outlines. < 1201622850 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://en.wikipedia.org/wiki/Joy_%28programming_language%29 good primer. < 1201622855 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :basically, it's a functional, concatentative language, < 1201622876 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but instead of formal parameters and function application, it has program quoting and evaluation < 1201622885 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :kind of like underload, but less crazy < 1201622894 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the wikipedia article is all i've read about joy, probably. < 1201622900 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :haven't used it < 1201622910 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :give it another read, as a refresher < 1201622931 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm, [] is a false-like lambda? < 1201622938 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a generic grouping thingie < 1201622944 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'llr ead. < 1201622948 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*typo < 1201622953 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: < 1201622954 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no < 1201622956 0 :Tritonio_!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201622961 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[...] is a program < 1201622979 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and you can run it, or use e.g. a combinator to do stuff with them < 1201622982 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :x == [x]i < 1201622990 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(i is the 'just run it' combinator) < 1201623110 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, that's what i meant by a grouping thingie < 1201623117 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can use that to get a list < 1201623125 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :not well, but kinda! :) < 1201623134 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyways, i know what it is. < 1201623147 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :I'm trying of thinking of some non-lazy evaluation command. How's this? ``>A[B] converts to `A[B], and immediatly afterward, [B] is evaluated. < 1201623175 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: just don't if it's for IO < 1201623176 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :monads < 1201623181 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: okay < 1201623185 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: my language is kind of like that < 1201623194 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :I cannot undersandy monads. < 1201623201 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Newton was against Monads! < 1201623204 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: Don't write a functional programming language until you do. < 1201623226 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: one distinguishing thing is that it has no special syntax apart from [...] < 1201623242 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Is there a better source than Wikipedia on it? < 1201623251 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yeah, i don't like that < 1201623257 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: what don't you liek < 1201623265 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :my prog language has nothing but [..] < 1201623267 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but joy has things like < 1201623267 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the DEFINE thing < 1201623271 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :"DEFINE x == y." < 1201623271 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1201623277 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm assuming you meant,,.... well, yeah < 1201623290 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's kinda impure. :P < 1201623294 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(sadol ftw!) < 1201623325 0 :Insane!unknown@unknown.invalid PRIVMSG #esoteric :My prog language has: +-><[].,*~!% < 1201623384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :P := '[' P* ']' | (!WS)+ P | < 1201623384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :P := '[' P* ']' < 1201623384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : | (~S)+ S P* < 1201623384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : | S < 1201623384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : | P* < 1201623385 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :S := ' ' | '\t' | '\n' < 1201623387 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :errrr < 1201623389 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :wait < 1201623405 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://rafb.net/p/w9QzSK93.txt < 1201623405 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :there < 1201623408 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :that's my languages syntax < 1201623415 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(if we assume ~X means 'anything but x') < 1201623425 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm wait < 1201623427 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you can also do < 1201623428 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :a[b]c < 1201623431 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but whatever. < 1201623432 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you get the idea < 1201623445 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oh wait < 1201623449 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i also have string literals. < 1201623450 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201623451 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1201623470 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :looks ambiguous < 1201623478 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :maybe my BNF is < 1201623480 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but the language isn't < 1201623482 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :honest :-) < 1201623498 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, ofc not < 1201623527 0 :Insane!unknown@unknown.invalid QUIT :Remote closed the connection < 1201623531 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :anyway < 1201623540 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i'm not sure how i'm doing to do assignment in my language < 1201623540 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :XD < 1201623551 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :without adding extra syntax, or using something ugly like a string literal < 1201623560 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, the purest way is not to :) < 1201623577 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but that's not a *good* way < 1201623898 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i mean, fuction definitions < 1201623903 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :which I need since I hav eno paraemters :P < 1201623915 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i guess i could maybe manage one bit of syntax... < 1201623929 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :WORD = WORD*. < 1201623936 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So, just like Joy but without the DEFINE thing < 1201624081 0 :Tritonio_!n=Tritonio@150.140.228.88 JOIN :#esoteric < 1201624336 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: is that ok with you? ;) < 1201624346 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it just means you can't define = as a word, and the parser needs a lookahead of one word. < 1201624366 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201624378 0 :timotiis!n=timotiis@jfkew.plus.com JOIN :#esoteric < 1201624400 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'd make case putting an atom on the stack and using it as a function < 1201624405 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1201624412 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'd make case differentiate between putting an atom on the stack and using it as a function < 1201624427 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: inconsistent, though - and there's no need for atoms elsewhere :) < 1201624430 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So, I think I like this idea. < 1201624434 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :OK! Time to write some example code.. < 1201624439 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :atoms are great, though < 1201624453 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but, do what you want < 1201624456 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :inconsistent? < 1201624458 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :how? < 1201624473 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you define as Abc, you use as abc < 1201624494 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmn < 1201624494 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i might use ; instead of . < 1201624501 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: what do you think i should use as a terminating mark? < 1201624516 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm, depends < 1201624520 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :can you redefine? < 1201624526 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :not sure yet. < 1201624546 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'd put ";" if you can redefine, otherwise "." < 1201624564 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: hm, why? < 1201624578 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :no reason, except a feeling. < 1201624586 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'll go buy something pretty -> < 1201624591 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(thirsty) < 1201624820 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Really -- all my esoteric programming endeavours are just part of the search for the perfect programming language (for me). < 1201624837 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I continuously try new abstractions, while removing others. < 1201624892 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :What's the best so far! < 1201625051 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I don't know. < 1201625055 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :It seems both extremes work equally. < 1201625066 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Haskell, Lisp, Joy, Cat... they all seem to be just about the same. < 1201625072 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :But I'm not sure they're good *enough*. < 1201626086 0 :Corun!n=Corun@halls-129-31-72-183.hor.ic.ac.uk JOIN :#esoteric < 1201626366 0 :Corun!unknown@unknown.invalid QUIT :Client Quit < 1201626423 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: you bacj yet? < 1201626451 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Hmm < 1201626457 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Maybe I'm looking in the wrong place. < 1201626474 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Maybe my options of: REPL-based, batch compiler, batch interpreter are wrong. < 1201626483 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Maybe my options of: unicode text file are wrong < 1201626805 0 :jix!unknown@unknown.invalid QUIT :"CommandQ" < 1201626936 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :o < 1201627251 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::| < 1201627255 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: comments? < 1201627286 0 :oklofok!unknown@unknown.invalid NICK :oklopol < 1201627318 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what do you mean by options? < 1201627413 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, like what i aim for when designing < 1201627420 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :like, maybe programs aren't inherently flat text files < 1201627429 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :maybe implementations don't have to be one of the things i said. < 1201627573 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i don't consider those that important < 1201627583 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so... hard to say. < 1201629420 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :The monads tutorial seems to require some knowledge of Haskell < 1201629505 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: gasp. < 1201629506 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1201629514 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :WHAT A SHOCK! < 1201629529 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :I guess I'll have to learn Haskell after all. < 1201629744 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://sigfpe.blogspot.com/2006/08/you-could-have-invented-monads-and.html http://www.haskell.org/haskellwiki/Monad_%28sans_metaphors%29 < 1201629748 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :the latter is just a 'WHAT is a monad' < 1201629754 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :the first is 'WHY is a monad' < 1201629830 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Apparently, I could have invented them! < 1201629834 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :I'm flattered. < 1201630667 0 :Tritonio__!n=Tritonio@150.140.228.53 JOIN :#esoteric < 1201630671 0 :Tritonio_!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out) < 1201630757 0 :Rocker[box]!unknown@unknown.invalid NICK :RockerMONO < 1201630831 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1201630892 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Hello sir. < 1201631027 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Hello < 1201631042 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :what's up? < 1201631054 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :ACTION got a dialect of brainfuck that uses sockets working < 1201631061 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :as ehird said in reply to my exact question: the sky :P < 1201631090 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :well... it works until the socket disconnects.... but if you leave an IRC bot made in it up for 14 and a half hours after it disconnects, it will be ugly :< < 1201631113 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Imma reading sum monads < 1201631122 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :In the hope of making some useful input function < 1201631126 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :mmm < 1201631129 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: and output! < 1201631133 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :all IO :) < 1201631147 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :psh why not II or OO? =P < 1201631148 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :You can even do state with monads, just add a magical monad-creator combinator and you can write a state monad :P < 1201631149 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Well, output seems to work okay so far. < 1201631153 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :btw < 1201631157 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :what's a monad? < 1201631163 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: yes, but if you do one you have to do the other, otherwise things go weird < 1201631165 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :RockerMONO: I'm still wondering! < 1201631174 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :RockerMONO: 1.learn haskell 2.learn monads < 1201631178 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :But I hope that the mystery will soon be lifted < 1201631202 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :It's apparently from category theory, that one from which I don't know squat. < 1201631236 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: you don't need to know category theory < 1201631239 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I don't! < 1201631321 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Well, I also don't know Haskell. < 1201631332 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :But I guess Haskell is easier to learn! < 1201631351 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :[Narrator : AND THAT WAS HIS FATAL MISTAKE] < 1201631414 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :HE DIED < 1201631416 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :LIKE A TORTOISE < 1201631418 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :IN A BATH < 1201631454 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :This was brought to you by the campaign against functional languages. < 1201631650 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Slereah: #haskell! < 1201631658 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :We're Friendly(TM) < 1201631698 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :MY GOD < 1201631702 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :IT'S FULL OF STARS! < 1201631869 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1201632071 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hello oerjan < 1201632077 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :make Slereah's #haskell-time fun and fuzzy < 1201632090 0 :jix!n=jix@78.47.212.92 JOIN :#esoteric < 1201632248 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Well, I'll probably read haskell tomorrow. < 1201632253 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :After a night of sleep. < 1201632261 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Don't have many classes tomorrow. < 1201632350 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Well, more than I thought. They added some more. < 1201632366 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :But I still have nothing on fridays. < 1201632633 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION just says "aye" to that. < 1201633253 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Hello oerjan < 1201633269 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :Thanks (once again) for cleaning up the mess I leave on the wiki :D < 1201633367 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i think ais523 did the last cleaning up, actually < 1201633394 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :well, nontheless, thanks for moving my page and what not :) < 1201633456 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I wonder < 1201633465 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :If a minimal combinator can be "i" < 1201633469 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that was him. he's not here right now (he just comes for short periods) < 1201633475 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :to get an entire TC system, < 1201633484 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :what is it for a stack based language? < 1201633485 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, they < 1201633486 0 :Hiato!unknown@unknown.invalid PRIVMSG #esoteric :oh, woops, well thanks anywho for the typo thing etc :) < 1201633494 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i imagine it requires multiple: dup and all that, for stack manipulation < 1201633495 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i'm thinking: < 1201633506 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :quoted programs + basic stack manipulation words + ??? magic thing ??/ < 1201633528 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :-> AWESOME LANGUAGE??? < 1201633538 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Solve for X. < 1201633565 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we just need to figure out magic thing < 1201633565 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201633588 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Well, I just use an electronic wand, personally. < 1201633600 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :3.5 megathaums. < 1201633633 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ehird: have you looked at Joy? < 1201633651 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :It can be used to solve most undecidable problems. Although cannot force someone to love you, as you can learn in Alladin. < 1201633692 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :someone did a paper on doing combinators in Joy < 1201633752 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION wonders if ??? magic thing = dip < 1201633988 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: of course! < 1201633995 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :my neu language is based on joy, kind of. < 1201634001 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it's a functional, stack-based language so yeah < 1201634066 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it might be dip, yes < 1201634080 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: i've considered a statically typed Joy -- like Cat -- but with type inference < 1201634092 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so it's just like a regular concatentative lang, except it yells at you when you write something silly < 1201634095 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :um Cat is supposed to have type inference < 1201634098 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :afair < 1201634105 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: its not that good though. < 1201634108 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i might even handle variadic functions < 1201634110 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :like < 1201634121 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you could write a printf which took an argument off the stack when it saw a certain formatting directive < 1201634124 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and it'd type properly < 1201634193 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well you'll have to invent a more clever type system than cdiggins did. < 1201634217 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :indeed < 1201634221 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i think a printf type could be: < 1201634237 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and he had some help from lambda-the-ultimate.org < 1201634239 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ok, sprintf: < 1201634245 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: this is true, i think it may be undecidable < 1201634264 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :( ... STRING -- STRING ) < 1201634269 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :a bit vague, i guese < 1201634283 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but it gets the essentials right: you need a STRING on the stack, and might need other stuff, and you'll get a string back < 1201634312 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :my understanding is that it essentially boils down to the undecidabilit of word equations < 1201634323 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*my intuition, perhaps < 1201634329 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i guess < 1201634346 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: the reason i said STRING is because lowercase is reserved for polymorphism < 1201634364 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :swap ( a b -- b a ) < 1201634384 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :let's assume forth style definition syntax: < 1201634386 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201634388 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :this is something.. < 1201634397 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: can you write the S combinator in J? < 1201634408 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :my intuition is that you cannot capture its first argument in the quoted program it should return < 1201634458 0 :RockerMONO!unknown@unknown.invalid QUIT :"Firefox using HALF OF MY FUCKING RAM and HALF OF MY FUCKING CPU :<" < 1201634469 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i know very little about J < 1201634502 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i guess < 1201634522 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you're not just abbreviating Joy, i assume? < 1201634526 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201634527 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i meant joy < 1201634528 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :xD < 1201634568 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :as i implied, someone has shown how to rewrite SKI combinators in Joy, so yes < 1201634572 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: factorial ( INT -- INT ) [zero?] [1] [1 -] [*] iter-rec ; < 1201634599 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: iter-rec ( PROG PROG PROG PROG -- a ) .... ; < 1201634602 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but that's not very helpful < 1201634605 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so i'll describe iter-rec < 1201634618 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :( TERM BASE STEP BINOP ) < 1201634626 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :TERM is the termination predicate. < 1201634632 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :BASE is the value to use at termination. < 1201634638 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, the program to execute. < 1201634652 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :STEP is what we should repeat on, given the previous value. < 1201634669 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :And BINOP is what we should apply to the next and previous values. < 1201634686 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201634688 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :better iter-rec: < 1201634716 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: iter-rec ( a ( a -- BOOL ) ( -- a ) ( a -- a ) ( a a -- a ) -- a ) ... ; < 1201634744 0 :RockerMONO!n=Nick@ip72-209-217-139.dc.dc.cox.net JOIN :#esoteric < 1201634745 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :which is insane, but good :D < 1201634757 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Do you think that's a general kind of recursion or is it only going to be usful for a factorial? ;) < 1201634837 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :ACTION wonders why this channel loses topic parts and modes each time he joins.. < 1201634839 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :=P < 1201634870 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :modes? < 1201634885 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION hadn't noticed the modes. actually still haven't. < 1201634894 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: any thoughts on iter-rec? < 1201634904 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it makes my head hurt? :D < 1201634908 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: nvm it was just lag =P it showed 'no modes' now it shows +nc =P < 1201634918 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1201634919 0 :Slereah!unknown@unknown.invalid TOPIC #esoteric :10 : Continuing the tradition of me changing the topic when I get up, the topic is now GOTO 10 < 1201634933 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Well, i'll annoate the type fully < 1201634937 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :Slereah :DD < 1201634953 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :Look around you! < 1201634965 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :one thing, ( -- a ) is just a unless you are doing side effects < 1201634978 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no < 1201634981 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :its a constant < 1201634983 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[1] < 1201634991 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well < 1201634995 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you could do side effects too < 1201635000 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :maybe i'll pass in a value at some time < 1201635001 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but for now.. < 1201635170 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i guess it is at least as powerful as a while loop, so can give TC < 1201635190 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :at least if a can be a tuple type < 1201635209 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or some sort of composition < 1201635228 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(a stack, probably?) < 1201635302 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: i was asking re: expressivity < 1201635313 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :here, have annotations: < 1201635340 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://pastebin.ca/raw/880225 < 1201635366 0 :RockerMONO!unknown@unknown.invalid PRIVMSG #esoteric :ACTION 's making screwbin, binary counterpart for brainfuck :D < 1201635367 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: using that definition, and seeing how it works with the factorial example, would you say iter-rec is an expressive recursive operator, or will it be ugly for things beyond factorial-alikes? < 1201635523 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it's a bit primitive recursive, although not exactly < 1201635536 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i don't think you can write ackermann with it < 1201635614 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(simply) < 1201635636 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :as in, you can only make one recursive call < 1201635704 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: its not meant to be general < 1201635707 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :just one in a toolbox < 1201635716 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i'm just asking if it's elegant for many other things than a factorial? < 1201635761 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it's like a haskell unfoldr + foldr < 1201635781 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1201635789 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I guess it's useful then < 1201635828 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: bin-rec ( a ( a -- BOOL ) ( -- a ) ( a -- a ) ( a -- a ) ( a a -- a ) -- a ) ... ; < 1201635841 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although for the full power of that, you want to distinguish some of the a's < 1201635871 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :actually it is not a complete unfoldr < 1201635901 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :though that can be adjusted in the combining function, so not a problem < 1201635922 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: give me a syntax for lists < 1201635924 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it's iterate + takeWhile + foldr < 1201635927 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and i'll give you a quicksort with bin-rec < 1201635932 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and that actually sounds very useful then < 1201635936 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1201635951 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :if you look at factorial with a grokking of iter-rec, it's very clear < 1201635973 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no stack shuffling or any of that, just the algorithm stated concisely, purely and simply < 1201635990 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and bin-rec can trivially be tail-recursive! < 1201635994 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or iterative < 1201635997 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :err < 1201635998 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :iter-rec < 1201636005 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :which remidns me. list syntax :P < 1201636087 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :head tail : ++ < 1201636101 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: heh < 1201636107 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i meant a convenient way to say [a,b,c] < 1201636112 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :not using [] for obvious reason :P < 1201636140 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ah yes, i think Joy uses the same for both but that is bad for typing < 1201636181 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well there is only one actual bracket left, { } < 1201636237 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :actually you _could_ use [a,b,c] < 1201636253 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :saying a b and c are subprograms < 1201636260 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er wait < 1201636266 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :breaks for single element < 1201636423 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :okay then: < 1201636430 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :wait no < 1201636433 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: {} is taken < 1201636435 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i assume type inference means the initial ( ... ) in a function could be left out, so that spot makes it unsafe to use something with ( ) < 1201636436 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :for {* comments *} < 1201636449 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :<, > are used for comparison for now < 1201636452 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :plus <1 2 3> is ugly :P < 1201636460 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :bah, i need unicode < 1201636460 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1201636472 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :seems you need a multi-char keyword < 1201636479 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201636480 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :like what < 1201636482 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ok, (, a, b, c) < 1201636499 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or [, a, b, c] < 1201636635 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :for a slightly harder parsing, the initial , could be optional when there is more than one < 1201636636 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201636640 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :there's no need for a, b, c < 1201636643 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :just a b c < 1201636648 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201636649 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :since you can have it gobble off the stack < 1201636673 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :[, a b c] < 1201636693 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i don't particularly like that. Maybe: < 1201636698 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :{{..}} < 1201636702 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :kinda ugly though < 1201636705 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :{: ... :} < 1201636712 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :{: 1 2 3 :} < 1201636714 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :{: :} < 1201636715 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm another option < 1201636725 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :eh, let's do {: ... :} for now? < 1201636727 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ok: < 1201636729 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :[a b c]: < 1201636736 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i'd prefer < 1201636737 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :,[a b c] < 1201636745 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes, i like that, let's use that FOR NOW < 1201636749 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :because : could be an actual function < 1201636760 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no, oerjan. : is define < 1201636770 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :anyway, bin-rec has gone off my screen. stop talking while i write quicksort :) < 1201636772 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well something could be < 1201636843 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: quicksort uncons [length 2 <] [{,}] [swap dup peek <] [swap dup peek >] [concat] ; < 1201636847 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :with syntax: < 1201636849 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :{,1 2 3} < 1201636854 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but, my problem with that < 1201636857 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :is the stack manipulation < 1201636881 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: quicksort ( {,a} -- {,a} ) uncons [length 2 <] [{,}] [swap dup peek <] [swap dup peek >=] [concat] ; < 1201636886 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :made it work, added a type signature :P < 1201636892 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: but that stuff to get to the pivot is pretty ugly < 1201636953 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :quicksort needs O(1) mutable arrays to be worthwhile anyhow < 1201636992 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :mergesort is better for actual linked lists < 1201637047 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1201637070 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :ACTION goes back to work on Mulambda < 1201637137 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: the language is tentatively called LION < 1201637140 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or just Lion < 1201637191 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :the object structure is very simple incidentally: just a pointer, if the rightmost bit is 0 the rest of the object is a pointer to something (where *ptr == the type tag structure, and everything after that the data), otherwise the rest is a small integer < 1201637220 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :lambda in one ... ? < 1201637239 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: ? < 1201637246 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(inspired by Scheme in one defun) < 1201637246 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, the rightmost bit would be 0 < 1201637249 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201637250 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :haha < 1201637251 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1201637260 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Lambda in one .. node? < 1201637262 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Really, we want: < 1201637277 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Quoted program in one word definition < 1201637283 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :qpiowd isn't very catchy though. < 1201637288 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201637316 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :#define SMALL_MAX ((~7)>>3) < 1201637321 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :wait < 1201637323 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :>>3? < 1201637325 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no no no < 1201637325 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :haha < 1201637329 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :((~1)>>1) < 1201637340 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: nifty little definition no? < 1201637406 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: interestingly, ptr-to-int is just -1 ;) < 1201637409 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and vise-versa! < 1201637479 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :how is ((~1)>>1) different from ((-1)>>1) ? < 1201637512 0 :immibis!n=immibis@125-236-142-87.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1201637515 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or ((~0)>>1), for that matter < 1201637541 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: well, it shouldn't be < 1201637543 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i just want < 1201637547 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :...111111111111111111111111110 < 1201637564 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and you're right with ~0 < 1201637564 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er that 0 the most significant digit? < 1201637565 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201637567 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :((~0)<<1) yoy mean? < 1201637570 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :*you < 1201637572 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :immibis: no < 1201637578 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i want the maximum value stuffable, if you lose one bit < 1201637591 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So currently that's ((~0)>>1) but I think -1 is right < 1201637593 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION would call that 0111...1 < 1201637596 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or something < 1201637605 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Welp, I stuff on the rightmost bit. < 1201637611 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :And so does mzscheme, so I have backing here! < 1201637622 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :righmost, shmightmost < 1201637642 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i'm a mathematician, i expect the least significant bit to be rightmost < 1201637690 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and >>1 shifts off the least significant bit afaik < 1201637717 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :leaving the most significant bit 0, assuming sign bits don't duplicate < 1201637724 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: You are confused. < 1201637732 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I am accessing WHAT I CAN HAVE, NOT packing stuff ina value < 1201637737 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :4>>1 == 2, right? < 1201637742 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so, an example packed small integer: < 1201637747 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :1101 < 1201637748 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Or pointer: < 1201637750 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :1100 < 1201637760 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So: least significant, rightmost. < 1201637774 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ok but: < 1201637786 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :1...1110 is <<1, not >>1 < 1201637797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: your -1 relies on twos complement < 1201637804 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :true < 1201637812 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Yes! Exactly! So I get 1...110, shift it to the right, then get 0...111 < 1201637812 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :ehird: it's still <<1 < 1201637818 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Which is the maximum value a small integer can be! < 1201637820 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Damnit!!! < 1201637831 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :This is when I read in an integer! < 1201637836 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :To tell if I can stuff it into the pointer directly! < 1201637850 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ehird: ok i was confused but you started it :D < 1201637870 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so ...1110 is the internal integer format < 1201637879 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :...1111 actually < 1201637881 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and >>1 turns it into ordinary C format < 1201637881 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :0 is for the pointers < 1201637882 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201637885 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :And yes, that is right < 1201637908 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION assumes it's cleared up now < 1201637910 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Cute trick: < 1201637911 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :#define IS_SMALL(x) ((x)&1) < 1201637938 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :LION sp; /* JESUS CHRIST IT'S A LION STACK POINTER GET IN THE CAR */ < 1201637941 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :^^ i am tempted ... < 1201638044 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and later, /* ARGH CLOSE THE WINDOWS */ < 1201638124 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: evidently internet memes never effect you < 1201638125 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201638127 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :*affect < 1201638129 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :*eh whatever < 1201638142 0 :Hiato!unknown@unknown.invalid PART #esoteric :? < 1201638167 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's a meme? < 1201638188 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :indeed i browse relatively few sites < 1201638208 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :'JESUS CHRIST IT'S A LION GET IN THE CAR' is a meme, yes < 1201638211 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it's died down by now < 1201638222 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION get Larson vibes < 1201638226 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*gets < 1201638231 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i'm not sure though < 1201638300 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ah, probably not < 1201638336 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or rather, i am reminded of a Larson strip where a lion has a cloth-hanger < 1201638463 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*clothes < 1201638485 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(#¤%& english) < 1201638505 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : sp = 195948557; < 1201638511 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hilarious! < 1201638547 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : csp = 195935983; < 1201638548 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hahahahhaa < 1201638566 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is confused. again. < 1201638582 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :do you just find numbers funny, or what? :D < 1201638624 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: you will figure it out, if you have the fu of not 10. < 1201638629 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(yes, i am being deliberately obscure) < 1201638658 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: when you get it, explain it to me in pm < 1201638664 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i don't wanna look stupid < 1201638684 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hah < 1201638685 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it's not that hard < 1201638695 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hint: that's in my initialization function. it's for future error checking < 1201638743 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :whatever < 1201638808 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :sigh, ok < 1201638829 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :sp = 0xBADF00D; < 1201638831 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :csp = 0xBADBEEF; < 1201638836 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but i'm changing BADBEEF to DEADBEEF < 1201638844 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :because that more accurately describes a call stack underflow < 1201638878 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you spoiler! i was just starting trying base conversions. < 1201638888 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :for some reason tried binary first < 1201638902 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i thought 'whatever' meant 'i gave up' < 1201638903 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201638914 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :"whatever, i'm not gonna play your stupid games" < 1201638926 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :("mwahahaha, i'm so gonna crack this") < 1201638944 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er, my giving up passed away < 1201638952 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :could've been "lololol!" < 1201639013 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that badf00d actually caused me some confusion, because those 0's _do_ show up prominently in base 2 < 1201639034 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but my brain was just too slow this evening < 1201639184 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Should Lion have a call/cc < 1201639186 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :? < 1201639186 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::D < 1201639192 0 :jix!unknown@unknown.invalid QUIT :"CommandQ" < 1201639221 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :might be easy if you have a linked-list execution stack < 1201639237 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, even if not < 1201639258 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Well, I don't :P < 1201639292 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :what are you writing it in? < 1201639301 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :C, duh. Didn't you see my #defines? :P < 1201639312 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er... < 1201639328 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION de-evolves further to the neanderthal stage < 1201639331 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hahah < 1201639340 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :don't worry, i'm going to write it simply < 1201639341 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201639346 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :THAT NOT FLINT < 1201639368 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :isn't defining like coarsening? < 1201639595 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Feel free to help me implement it in Haskell. ;) < 1201639622 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :OH NOW YOU DON'T TALK < 1201639733 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :TOO LONG WORD, HAS, HAS, THAT ONE < 1201639802 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So now you don't like Haskell either? :P < 1201639820 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :IS GREAT. JUST NOT CAN SAY IT. < 1201639854 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: WILL HELP IMPLEMENT LION HASKELL? < 1201639861 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :primitive :: Stack -> Stack LIKE MUCH < 1201639912 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :maybe < 1201639927 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yay < 1201639937 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :C can wait until we've verified the awesomeness of it, I guess :P < 1201640327 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I have an idea for mutability < 1201640341 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :instead of doing like < 1201640345 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(IORef Value) < 1201640349 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :in various clauses of Value, < 1201640350 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we can do < 1201640352 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Location < 1201640360 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :where Location is an Int index, in a heap array < 1201640367 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and we can just modify that array.. < 1201640375 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :perhaps ugly, perhaps not. oerjan: thoughts? < 1201640411 0 :Hiato!n=Hiato@dsl-245-57-28.telkomadsl.co.za JOIN :#esoteric < 1201640431 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well i think that's the usual way of simulating mutable structures in pure code < 1201640450 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it gets ugly if you have more than one type of value though < 1201640477 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :also, you don't get the benefit of automatic GC < 1201640491 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: is it? < 1201640492 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ok. < 1201640499 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: of course, at any time a function could do some IO < 1201640505 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so maybe we'd be best off using IO and IORef < 1201640513 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :right < 1201640517 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :But if we do that < 1201640529 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :should we still have (Stack -> Stack), well, now, (Stack -> IO Stack)? < 1201640533 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Or just: < 1201640540 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :StackMonad () < 1201640547 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :where StackMonad is IO with a stack in it, heh < 1201640576 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well you could have a StackMonad even if you don't keep the Stack in an IORef < 1201640590 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :ACTION needs some Garry Gum < 1201640594 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(StateT Stack IO for example) < 1201640618 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Yes. < 1201640629 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I propose: < 1201640638 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :type Stack = StateT [Value] IO < 1201640643 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So we can have "primitive :: Stack ()" < 1201640648 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Just looks a bit nicer, I guess. heh. < 1201640685 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er < 1201640695 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so the actual stack is [Value] < 1201640709 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's a bit confusing terminology < 1201640745 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Well, yeah < 1201640748 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :top : rest < 1201640752 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :A stack is just a linked list < 1201640764 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er not that < 1201640768 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but, < 1201640771 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's perfectly reasonable. < 1201640774 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :haskell compilers can do optimizations on lists. < 1201640775 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1201640775 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ok < 1201640778 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i mean calling the monad Stack < 1201640790 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yeah i know < 1201640794 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it's just... :-) < 1201640797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201640801 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :let's say its called StackMonad < 1201640805 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :drop :: StackMonad () < 1201640814 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :drop = do (_:xs) <- get < 1201640821 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : put xs < 1201640829 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric : return () < 1201640835 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I dunno. :| < 1201640838 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :As opposed to: < 1201640842 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :drop :: Stack -> IO Stack < 1201640844 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :drop = modify tail < 1201640848 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :drop (_:xs) = return xs < 1201640852 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I guess. < 1201640860 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I just guess I see everything as a stack to stack mapping < 1201640882 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although yours has the advantage we can add an error layer easily < 1201640911 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :both of yours, really < 1201640913 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Which do you prefer? A stack monad, with IORef for all mutable things, or a stack to stack mapping function that has an IO monad attached to it? < 1201640965 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i think perhaps Stack -> IO Stack is better, nearly all the functions will need to look at the stack anyhow < 1201641002 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: One thing < 1201641003 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and few will need to return any other value < 1201641006 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :if we're going to do static type checking < 1201641013 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201641015 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we need to make that pleasant to deal with in our primitives < 1201641031 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i.e. specifying a type for them, and all that jazz < 1201641033 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION actually has no experience implementing that < 1201641045 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Me neither! < 1201641052 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :And especially no experience implementing type inferrence. < 1201641069 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Still. < 1201641088 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I'm not sure which of our options -- or a third -- will make specifying the primitive functions and their types easier < 1201641326 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: In fact, how will we specify the types at all? < 1201641394 0 :helios24!unknown@unknown.invalid QUIT :"Leaving" < 1201641410 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :afk < 1201643413 0 :ehird!unknown@unknown.invalid QUIT :"Leaving" < 1201643528 0 :ehird!n=ehird@user-514fb24f.l2.c4.dsl.pol.co.uk JOIN :#esoteric < 1201644094 0 :cherez!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201644644 0 :unrepresentative!n=Foo_Bar@mon75-14-88-163-179-251.fbx.proxad.net JOIN :#esoteric < 1201644664 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: < 1201644669 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :any thoughts? < 1201644674 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :on typability and mutability and taht stuff < 1201644841 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i recall faxathisia yesterday was trying to implement type inference for simply typed lambda calculus in haskell < 1201644911 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :also, that will not be enough for a stack language < 1201644981 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i actually didn't look at what Cat ended up with < 1201645199 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: i tell you what < 1201645202 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i'll get ghc back up < 1201645209 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :then let's just see how it goes, when we try and write it < 1201645330 0 :GreaseMonkey!n=saru@219-88-194-41.jetstream.xtra.co.nz JOIN :#esoteric < 1201645575 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1201645583 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I think, data types: < 1201645615 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :1. Integer 2. Float 3. Program 4. Primitive 5. List < 1201645618 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Maybe 6. Vector < 1201645641 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :2. Double < 1201645676 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Bah, ok. But still have a float? < 1201645683 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :why not < 1201645747 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :perhaps Tuple < 1201645758 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or is that what you mean by Vector? < 1201645788 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :anyway more of those are easy to add, i think < 1201645941 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Vector is a numerically-indexed, consecuative in memory O(1) access structure < 1201645944 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(aka 1-dimensional array ;)) < 1201645963 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Tuple, maybe but i'm not sure < 1201645968 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :mostly you would just use the stack for that < 1201645986 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I think we should get basic object and stack operations, then write the parser. It often helps enlighten. < 1201646059 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Should types be first class objects? < 1201646066 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no < 1201646068 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So you could do INT and get the integer type pushed to the stack < 1201646070 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :aww, ok < 1201646073 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :that would be fun though < 1201646079 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it'd also make implementing (...) easy < 1201646080 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1201646081 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :then we get dependent types < 1201646083 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1201646085 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :good point < 1201646090 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and we are already in deep enough water < 1201646093 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :TYPE is a TYPE is a TYPE ... < 1201646115 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I'm naming all the constructors LName < 1201646116 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :like < 1201646119 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :LInt Integer < 1201646124 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :to avoid conflicts. < 1201646127 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :the actual type is Value, though. < 1201646140 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :not strictly necessary < 1201646151 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: should i not do it? < 1201646155 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :data constructors and type constructors are different name spaces < 1201646155 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i get confused when i see like < 1201646159 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :String "abc" < 1201646162 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or < 1201646163 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Int 2 < 1201646174 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: oh, extra type: String < 1201646186 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and thus character < 1201646194 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201646198 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :strings: immutable, or mutable < 1201646212 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but we'll need constructors for types and values, so need to have two sets of some anyhow < 1201646219 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :immutable < 1201646263 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :immutable? ok :| < 1201646274 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I seem to mutate strings all the time, when not programming in a really functional language < 1201646286 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(Lion isn't purely functional. Just you can utilize the functional paradigm to your benefit.) < 1201646321 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: instead of list, maybe we should have stack < 1201646333 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :when you have a dictionary and the keys can be mutated, you are in deep trouble < 1201646335 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but... i can't see you using a 'stack' structure heavily in programming, more than a list.. < 1201646339 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: this is true < 1201646353 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: maybe we should provide 'stack' and 'list' which are equivilent :P < 1201646364 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1201646381 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: both are (IORef [Value]) < 1201646393 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :actually < 1201646395 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :maybe we should do < 1201646416 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :newtype Stack a = EmptyStack | Stack a Stack < 1201646422 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :just to emphasise the difference < 1201646428 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but that might stop compilers optimizing < 1201646445 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :newtype Stack a = Stack [a] should work < 1201646462 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: pretty useless, though < 1201646466 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Wait. < 1201646469 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Should lists be immutable? < 1201646479 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Schemers seem to like their lists in Diet Immutable flavour.. < 1201646513 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: by the way < 1201646519 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :type Stack = IORef [Value] < 1201646520 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or < 1201646523 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :type Stack = [Value] < 1201646524 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :pick one < 1201646548 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :if the latter, then we get | LStack (IORef Stack) which is different from the stack in Lion programs < 1201646574 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :what is the stack in Lion programs? < 1201646586 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :they should definitely be interchangeable < 1201646597 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: the stack in lion programs is just a [Value] < 1201646602 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :with all the primitives being (Stack -> IO Stack) < 1201646652 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we could go the Ref way - having just one type that is mutable, and contains an arbitrary value < 1201646670 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: personally i don't like that < 1201646671 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :do you? < 1201646725 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: another note: double vs float - i don't want two because it will make the interpreter more complicated < 1201646740 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :right, so take the best precision < 1201646743 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I say Double < 1201646768 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: In: < 1201646769 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[a b c] < 1201646773 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :how do we represent the a, b and c? < 1201646783 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i.e. | LProg Type (WHAT?) < 1201646785 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :err < 1201646785 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :should be < 1201646789 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i.e. | LProg Type Type (WHAT?) < 1201646797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: speaking of which, what type is a data constructor < 1201646816 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201646817 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201646819 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :a function of its arguments, in haskell < 1201646825 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ah. < 1201646834 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so how do we represent 'a type in Lion' < 1201646864 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :also, values do not need to contain types < 1201646878 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201646878 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :true < 1201646884 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we can do that all pre-interpretation right? < 1201646890 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yep < 1201646894 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm, we will need a two-pass interpretation :-) < 1201646909 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :after parsing (which will not be able to parse into values, but some AST): < 1201646916 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :analyze all imports and that shiznit < 1201646922 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :gather up our types, do the inferrin' and the checksin' < 1201646933 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :get all yer AST, munge into values < 1201646935 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :interpret < 1201646964 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: oll korrect? < 1201646972 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :afaict < 1201646988 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: and the AST should be in Lion.AST < 1201646988 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :not Lion < 1201646998 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :because it's murky and most people would wet their pants upon seeing it < 1201647016 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201647021 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: So: LProg [AST] or LProg [Value] < 1201647029 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION thinks the same is true for ghc... < 1201647033 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[Value] would require that we resolve [a b c] into the programs that a, b and c represent < 1201647040 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :which is like forth and... you can't recurse with it < 1201647052 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So... [AST]? If so, that means we have to do analysis on quoted program call < 1201647060 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Which is... kinda lame. < 1201647076 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :LProg (Stack -> IO Stack) < 1201647087 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :theoretically enough < 1201647112 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: whoa, we're compiling? < 1201647115 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :.. when did that happen < 1201647144 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we might < 1201647153 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: and if we don't? :P < 1201647168 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :also, how would we construct the haskell? we can't exactly generate a string and pass it to eval.. < 1201647177 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we should use Harpy FOR THE SPEED OF IT! :p < 1201647210 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION has heard the word Harpy but isn't quite clear on it < 1201647264 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: it's a monadic haskell DSL for generating x86 machine code (and getting a function out of it) at runtime < 1201647276 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://uebb.cs.tu-berlin.de/harpy/ < 1201647279 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :not constructing haskell text, just using combinators to combine programs < 1201647293 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1201647306 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so, oerjan < 1201647310 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :are we compiling or not? < 1201647313 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well perhaps we should go via an AST first < 1201647315 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and if not, what data type for LProg? :P < 1201647324 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: oh, we will go via an AST < 1201647326 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :because < 1201647327 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh wait < 1201647332 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we have to analyze all the types and all that < 1201647336 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and THEN we can compile that < 1201647345 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we need LProg's to be available as runtime values < 1201647368 0 :Corun!n=Corun@halls-129-31-72-183.hor.ic.ac.uk JOIN :#esoteric < 1201647388 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: just to execute them < 1201647405 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: though we do need the types i think? < 1201647432 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm if we do imports < 1201647446 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :of already compiled modules < 1201647460 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :then they need to include types somehow < 1201647467 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although maybe not in the same file < 1201647469 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :exactly.. < 1201647475 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I think interpretation is our best best. < 1201647483 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :But then, we go back to the problem: What is an LPRog? < 1201647523 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the thing is < 1201647563 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :interpret (LProg prog) :: Stack -> IO Stack < 1201647584 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: what about it < 1201647600 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and that is the only way a prog is used < 1201647616 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: and getType :: LProg -> ??? < 1201647625 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so the prog could be just that, and interpret (LProg prog) = prog < 1201647632 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or it could be a list < 1201647635 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: and getType :: LProg -> ??? < 1201647639 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :think about, say, a REPL < 1201647644 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :when you enter an expression < 1201647646 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it has to typecheck it < 1201647649 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it is merely a question when we do the conversion to Stack -> IO Stack < 1201647649 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but all the compiled functions it has < 1201647652 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :don't have their types! < 1201647657 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :they're just (Stack -> IO Stack) < 1201647665 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so... whoopsy! < 1201647678 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am assuming this is at the time we have already done type inference < 1201647686 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: REPL. < 1201647689 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so values don't need to contain types < 1201647689 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :An interactive mode. < 1201647692 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Do you see the problem now? < 1201647704 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the dictionary for a repl < 1201647709 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :watch this < 1201647711 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: foo ( INT -- INT ) ; < 1201647713 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :would contain (Value, Type) pairs < 1201647721 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :"abc" foo {* foo has lost its type, so we can't check it *} < 1201647727 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: uhm what about the eval function < 1201647728 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :just saying < 1201647740 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i think that the best way is to have some kind of actual interpretation. < 1201647753 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :LProg Type Type ??? < 1201647760 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :The thing we need to fill in is ??? < 1201647760 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no types needed there < 1201647767 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: can you please read what i'm saying < 1201647770 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we need the types at runtime < 1201647774 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yes and i disagree < 1201647782 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: so explain. < 1201647789 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we don't need them in the values themselves < 1201647793 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :where do we need them < 1201647803 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we just need them in the toplevel REPL dictionary < 1201647826 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :each identifier comes with a value _and_ a type < 1201647827 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: REPL isn't the only instance of this. < 1201647862 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :if you have a dynamic language, where ANYTHING could happen at runtime, including loading files in mish-mash order, you NEED to store those types < 1201647871 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: OK then, let's pretend we don't need types < 1201647873 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Fill in ??? < 1201647878 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if it's dynamic yes < 1201647898 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Well, yeah. It is a dynamic language < 1201647900 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it could still be either [Value] or Stack -> IO Stack < 1201647902 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Not in types, but in other cases. < 1201647909 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: [Value] it could not be. < 1201647918 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[a b c] -> what Value do you use for a, b and c? < 1201647949 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201647989 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :exactly < 1201647993 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so the current only option is an AST < 1201647996 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :which is probably the best bet < 1201648018 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh i am not sure [Value] is impossible < 1201648023 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but i still think having types in the value -- even if not neccessary -- will make writing the interpreter trivial < 1201648035 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: basic rule of thumb: everything that's a Value you can put in a ( -- ) declaration < 1201648087 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am still not sure there is a problem < 1201648104 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: what is the value for a b and c then < 1201648117 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that depends, obviously, on what a b and c is < 1201648131 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if a = 1, probably just that < 1201648135 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no, oerjan < 1201648137 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i mean literally < 1201648138 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :[a b c] < 1201648161 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if a b and c are primitive functions < 1201648172 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: primitive or maybe defined.. < 1201648176 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and here's the main thing < 1201648179 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :functions can be redefined. < 1201648184 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oops < 1201648202 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :need to keep their types, right? < 1201648205 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :haha, did i just stomp out our compiler design < 1201648206 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: yes < 1201648218 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :otherwise you'd have to do major type rechecking < 1201648230 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and this would break the system: < 1201648233 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :: dup ; < 1201648252 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: so, it does have to be an AST doesn't it < 1201648254 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :realistically < 1201648264 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ah wait! we don't EVER have to convert an AST into Values < 1201648273 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :we just go through the AST and interpret it < 1201648277 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :just the stuff on the stack are Value-s < 1201648304 0 :timotiis!unknown@unknown.invalid QUIT :"leaving" < 1201648323 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well if functions can be redefined they need to be stored with their names/lookup keys < 1201648330 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or as IORefs < 1201648350 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: yes, we'll also gain global variables from this < 1201648351 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1201648358 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :maybe local variables would make some code clearer too < 1201648369 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :though lexical vars would be a huge overhead. < 1201648375 0 :oklopol!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1201648382 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: we have a (M.Map String Value) < 1201648390 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :eh, wait < 1201648394 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: we have a (M.Map String (Bool,Value)) < 1201648405 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Bool? < 1201648409 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :otherwise assigning a global variable to a program would have odd results (autocommandifies) < 1201648432 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :(isCommand,value). (True,aProg) or (False,anyValue) < 1201648459 0 :oklopol!n=ville@194.251.103.33 JOIN :#esoteric < 1201648474 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: that's ugly, of course ;) < 1201648556 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm perhaps < 1201648594 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :a program executes while a value places itself on the stack < 1201648603 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1201648627 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: actually, i think we should store the type in programs only used by things like the repl < 1201648632 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it'd just make the repl a lot easier < 1201648632 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201648633 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :no other reason < 1201648654 0 :Insane!n=ltkde@unaffiliated/insane JOIN :#esoteric < 1201648664 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: hmm, what to call the AST object? < 1201648668 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :AST or ASTNode or Expr or.. < 1201648717 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :assuming there is only one type of it, AST is fine? < 1201648771 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :its just not a tree < 1201648773 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :its a tree node < 1201648773 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1201648804 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION spontaneously rearranges ASTN and adds a Y < 1201648862 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1201648870 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ACTION adds an "i", because this channel lacks it < 1201648885 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I think Expr is good < 1201648921 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: hould we duplicate LInt/Char/String etc for the exprs? < 1201648923 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or should we have < 1201648926 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Constant Value < 1201648955 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :data constructors cannot be shared between types < 1201649031 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I meant < 1201649037 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :data Expr = EInt Integer | ... < 1201649044 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i prefer the Constant Value < 1201649145 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :-> food < 1201649151 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: d'aww < 1201649155 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i was just about to paste something < 1201649169 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :only from the fridge... < 1201649171 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :http://hpaste.org/5333 < 1201649173 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1201649174 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1201649232 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i just need the Type type ;P < 1201649239 0 :unrepresentative!unknown@unknown.invalid PART #esoteric :? < 1201649513 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: when you're back: what should Type be? < 1201649527 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's the hardest part i guess < 1201649542 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it'd mostly be a duplication of Expr. But without the constructor parameters < 1201649550 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we need Forall Var Type for polymorphism < 1201649564 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: whut < 1201649577 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er, do you know anything about haskell types? < 1201649591 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :enough to write most stuff! < 1201649596 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :But not Forall Var Type polymorphisms < 1201649605 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I kind of get the "forall a. ..." stuff though. If it's anything related < 1201649617 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yes it's for that < 1201649634 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm, perhaps Forall [Var] Type < 1201649650 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1201649662 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :stacks cannot be the same type as uniform lists < 1201649686 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :exactly < 1201649688 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :lists are immutable < 1201649691 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :stacks are an IORef < 1201649694 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no < 1201649699 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :uh yes, see my paste < 1201649700 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that is almost irrelevant < 1201649703 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :h < 1201649705 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :okay :P < 1201649714 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :lists contain only one common type < 1201649727 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :stacks need to be distinguished according to their contents < 1201649743 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Stack Type Type perhaps < 1201649745 0 :cherez!n=cherez@r02snw275.desktop.umr.edu JOIN :#esoteric < 1201649747 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: haskell lists or my list < 1201649754 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :because Lion lists are polymorphic < 1201649758 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :they're [Value] < 1201649759 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the first is the top type, the second the rest of stack < 1201649923 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if there is to be any hope of type inference, then there must be a difference between what corresponds to haskell's tuple-like and list-like types < 1201649935 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :yes, I guess < 1201649946 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :tuple-like means each position of the tuple (at least those positions we look at) must have a specific type < 1201649952 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :OK, lists are all of one type... Hm... I don't know how to express that in Value < 1201649970 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :list-like means all positions have the same type < 1201649980 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i don't think you can < 1201649989 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :without Oleg-level type hackery < 1201650039 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm, or... < 1201650052 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :maybe that's what they do with those GADTs < 1201650112 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that would mean having Lion types be more closely connected to haskell types < 1201650123 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: maybe we should stop using haskell's type system, the way this is going :P < 1201650130 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well < 1201650132 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :for Values < 1201650137 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :like < 1201650146 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :right < 1201650148 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :data Value = Value Type [... but then i wouldn't know what to put here obviously ...] < 1201650175 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :_either_ we make Value be completely dynamically typed, _or_ we need to be very clever with the haskell < 1201650205 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: i think being clever with haskell might make us bump into limimtations later on < 1201650215 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :right < 1201650227 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: OK, what zany magic does a Value become now? < 1201650318 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1201650332 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: Since I have no idea to say A BLOCK OF POLYMORPHIC MISHMASH since that is... not haskell's speciality < 1201650338 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Do we need to do weird pointer magic or something? :P < 1201650382 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :um i thought you said we _shouldn't_ be clever with the haskell < 1201650435 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: we shouldn't < 1201650440 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but i don't see another way to make Value polymorphic < 1201650461 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :we make Value polymorphic by ignoring all types in it < 1201650474 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :writing it as if the language is totally dynamically typed < 1201650476 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :I think i'm missing something. What is Value's data definition? < 1201650499 0 :Hiat1!n=Hiato@dsl-245-57-28.telkomadsl.co.za JOIN :#esoteric < 1201650522 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you might remove the two Type's from it < 1201650540 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am slightly worried about the IORef Stack < 1201650558 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :exactly how is it supposed to be legal to change a Stack? < 1201650585 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: by pushing to it and popping off it? < 1201650591 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or swappign two valus in it? < 1201650593 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :or dupping it? < 1201650595 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :JUST A THOUGHT < 1201650620 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and that can only be well-typed if all values in it have the same type < 1201650626 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :well, no. < 1201650630 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :It's just like the main program stack. < 1201650635 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Completely polymorphic < 1201650649 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :there's only a single stack type, STACK < 1201650653 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :it holds any value < 1201650681 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's not a single type in any static type system < 1201650696 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er < 1201650706 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that might be overgeneralizing < 1201650712 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: It is in this case, because otherwise the main stack would be badly typed < 1201650720 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no < 1201650723 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :So we have one magical kitten bunny unicorn polymorphic type. < 1201650736 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :in a concatenative language the type of the stack depends on time < 1201650743 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :where you are in the program < 1201650760 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :1 "abc" 2.3 [x y z] < 1201650767 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :that is totally polymorphic. < 1201650774 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :and having the stack as a first-class object is useful < 1201650777 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but if it is static like Cat then the type is still fixed at a given point < 1201650787 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: oh, in FUNCTIONS, sure. < 1201650792 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :that's just verified that the calls are OK < 1201650797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :but you can do whatever you want otherwise < 1201650797 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :also < 1201650804 0 :Corun!unknown@unknown.invalid NICK :RockTheDragon < 1201650806 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :runInStack :: Stack -> IO Stack < 1201650826 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so you want a lot of dynamic checking of stacks before passing them to functions? < 1201650841 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :runInStack (s : p : xs) = do foo <- readIORef s; return (interpret p s : xs) < 1201650856 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: We determine this before interpretation.. < 1201650889 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :Since all FUNCTIONS have well defined types, and all PUSHES do, we can determine if a CALL is well-typed, but the STACK itself is totally polymorphic. < 1201650958 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm... < 1201650990 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if you dup a mutable stack you are going to get aliasing problems < 1201651009 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: present a program (use any stdlib functions you want to do it) that is a problem with typing or whatever because i'm not seeing it < 1201651016 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: also, we copy objects with dupping, I think < 1201651025 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :entire stacks? < 1201651030 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201651049 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :in that case there is no point in making Stacks be in IORefs < 1201651075 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: yes there is < 1201651116 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :runInStack (p : s : xs) = do foo <- readIORef s; stk <- interpret p s; writeIORef foo stk; (s : xs)) < 1201651116 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1201651116 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :i guess you are right < 1201651121 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: but then stacks are just identical to lists < 1201651126 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :so i don't feel justified including them! ;) < 1201651134 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: oh < 1201651139 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :you can stuff stacks in something else < 1201651142 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :- say a structure - < 1201651145 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :without having them copied < 1201651149 0 :ehird!unknown@unknown.invalid PRIVMSG #esoteric :thus, they need to be iorefs < 1201651172 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but then you get aliasing problems again