00:02:12 -!- Traveler2 has joined.
00:02:27 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
00:03:06 -!- Traveler2 has quit (Client Quit).
00:17:20 <ehird`> (getchar()+1 || 1) - 1 /* clever trick for a BF-getchar */
00:25:44 -!- pikhq has joined.
00:28:13 <slereah_> What does this mean? Happy jew year?
00:30:30 <calamari> hope you guys have all these fonts, otherwise sorry for the line noise :)
00:31:36 <ehird`> there's probably irc-alikes with s-expressions
00:31:39 <calamari> Ge'ez or Ethiopic has been assigned Unicode 3.0 codepoints between U+1200 and U+137F
00:31:51 <ehird`> but what about irc alikes with stack-based text
00:32:12 <slereah_> Random esoteric idea. Transmit pieces of code to a million monkey with a million typewriter.
00:32:56 <ehird`> bsmntbombdood: no, unicode is wonderful
00:35:01 <slereah_> Unicode is full of chars you will never use.
00:35:22 <slereah_> 3 terabites of it are just asian characters.
00:35:24 -!- slereah_ has changed nick to Slereah.
00:35:57 <oerjan> English is full of words you will never use.
00:36:11 <ehird`> Slereah: I think asian people may disagree.
00:36:31 <oerjan> The phone book is evil!
00:36:43 <oerjan> The phone book is full of people you will never speak with.
00:37:07 <oerjan> And let me not even _start_ on wikipedia.
00:37:07 <faxathisia> you keep saying this but I don't understand why
00:37:10 <Slereah> My sister was once bitten by a mse
00:37:39 <ehird`> R6RS is evil, it's full of stuff you'd never want to use.
00:37:41 <oerjan> is that like a moose, except with an Inspector Closeau accent?
00:38:25 <ehird`> faxathisia: various people's arses
00:38:26 <Slereah> Everytime I read this acronym, I can't help but think of a little robot
00:38:39 <Slereah> R2D2's cousin or something
00:40:06 <faxathisia> hebrew don't celebrate new year anyway
00:40:42 <Slereah> I'm a jew, and I don't care for the jew calender!
00:40:50 <ehird`> Slereah: are you jewish or are you a jew
00:41:09 <ehird`> bsmntbombdood: Slereah *is* a jew
00:42:32 <ehird`> Slereah: Jewish means you adhere to the Abrahamic, one-mega-psychotic God religion
00:42:45 <ehird`> Jew means your heritage is Jewish
00:43:47 <calamari> http://en.wikipedia.org/wiki/Quinary
00:43:53 <calamari> someone figure out 2008 in that
00:44:20 <calamari> I get lost between 100 and 125
00:44:44 <calamari> according to the calculator I need to encode 401 + 3
00:46:57 <Slereah> Fuck that, I'll just use Mathematica
00:46:58 <ehird`> 'hello world' * 'main' channel say
00:47:01 <calamari> dambumiriw dambumirri rulu vs dambumirri dambumirri rulu
00:47:31 <oerjan> showIntAtBase 5 intToDigit 2008 ""
00:47:51 <pikhq> pslbnf { primary = /2+2/ => "4" print null };
00:47:55 <ehird`> (say (channel 'main') 'hello world') -> 'Hello, world!' 'main' channel say
00:52:00 <ehird`> i'm going to write a self-applicable scheme->forth compiler
00:57:15 <ehird`> faxathisia: it can compile itself
00:57:20 <ehird`> and the result can compile itself again
00:59:28 * oerjan has seen the term self-hosting for this
00:59:47 <ehird`> but self-applicable is a better term
01:00:01 <ehird`> self-hosting implies that if you repeat the process multiple times, it'll 'stack up' on self-hosts
01:00:45 -!- bsmntbombdood has quit (Connection reset by peer).
01:01:22 -!- bsmntbombdood has joined.
01:03:56 <faxathisia> ehird: Why don't you finish ISWYM first :P
01:05:35 <ehird`> faxathisia: 'cause it'll be a pain in the neck :P
01:12:11 -!- bsmntbombdood_ has joined.
01:17:15 -!- oerjan has quit ("Good night").
01:17:35 <ehird`> someone should write a brainfuck->unlambda translator
01:17:47 <ehird`> then, reduced-unlambda->ski
01:18:13 -!- bsmntbombdood has quit (Connection timed out).
01:18:18 <Slereah> I don't feel very motivated right now.
01:18:20 <faxathisia> brainfuck->unlambda translator souynds hardest
01:19:01 <ehird`> ok, bf->something-with-a-path-to-ski
01:19:08 <Slereah> How do you even make some sort of memory in Unlambda? Keep pairing elements?
01:19:55 <ehird`> Presumably, consing, yeah
01:20:00 <ehird`> bf->lambda-calculus might be easier
01:20:12 <ehird`> input should be specified in the prog!input form pre-compilation
01:20:22 <ehird`> and output should be extractable, somehow
01:20:36 <ehird`> so with a wrapper script, we could really have the slowest BF interp ever
01:21:09 <Slereah> Don't be so sure, I'm working on a 1 tape version as we speak!
01:26:24 <ehird`> does a signal handler call unwind the s tack?
01:34:22 <pikhq> Then a scheme->unlambda. :p
01:36:43 <ehird`> brainfuck->scheme should be simple, yeah
01:36:55 <ehird`> if you ensure no imperatives, you can ->unlambda
01:36:58 <ehird`> well, you could do imperative IO
01:37:02 <ehird`> but that won't survive the translation
01:37:09 <ehird`> thus output is not in R-unlambda
01:41:35 <GregorR> ehird`: No, the signal is called in the current context - the program continues executing where it was when the signal handler ends. So, no unwinding is done.
01:42:07 <ehird`> so, assuming i can get myself an invalid page in the right place, my signal handler just needs to realloc
01:42:13 <ehird`> the invalid page bit is the hard part
01:42:23 <ehird`> since even mmap makes no guarantees, unless you pass it the right flag, which can then make it fail
01:55:43 <ehird`> GregorR: any bright ideas?
03:15:46 <Slereah> BF on a one tape Turing machine is quite annoying to do.
03:16:03 <Slereah> I don't have a simple way to load a file on it.
04:50:38 -!- GreaseMonkey has joined.
06:14:14 <dbc> The program and the input both have to be in the tape to start with. Both are finite, and then you put the infinite brainfuck array after them. How are you setting tape state in the first place?
06:14:56 <dbc> You'll need a marker to distinguish the program from its input. I suggest '!' of course :)
06:17:09 <dbc> And then to separate the input from the array, hm. Maybe an EOF stored on tape. Then there are 257 tape symbols in total, which makes sense.
06:19:31 <pikhq> Well, of *course* you suggest !.
06:25:14 <Slereah> dbc : No need for input in the program
06:25:23 <Slereah> It's not just any Turing machine!
06:26:17 <Slereah> I think my version work right now.
06:28:20 <Slereah> The tape looks something like this : http://farm3.static.flickr.com/2143/2153953116_145ff9967d_o.jpg
06:28:50 <Slereah> @ indicates the beginning of the code, $ the current position, LF the end of it.
06:29:12 <Slereah> for the beginning of the memory, or for the current position.
06:29:31 -!- faxathisia has left (?).
06:29:48 -!- faxathisia has joined.
06:30:29 <Slereah> Since the machine has to travel most of the memory and code for each instruction, it will probably be a whole lot slower than the 3 tapes version.
06:47:21 <dbc> So it only handles brainfuck programs that don't take any input?
06:47:33 <pikhq> So, it handles P'' programs?
06:48:01 <Slereah> The Turing machine has an input function.
06:48:33 <Slereah> choice machine being this :
06:48:35 <Slereah> "For some purposes we might use machines (choice machines or c-machines) whose motion is only partially determined by the configuration (hence the use of the word possible in 1). When such a machine reaches one of these ambiguous configurations, it cannot go on until some arbitrary choice has been made by an external operator. "
06:50:08 <dbc> That's right, I think you said the 3 tapes version was slow. Why was that?
06:50:44 <Slereah> I tried some programs, some never finished
06:51:09 <Slereah> The mandelbrot.b ran for 10 hours, outputing two lines before I turned it off.
06:51:22 <dbc> Does it average more than ten Turing instructions per brainfuck instruction?
06:51:50 <dbc> Or did it take a long time to do each Turing machine instruction...
06:52:43 <Slereah> The number of instructions isn't fix. But there's less than 5 states per instructions read.
06:53:00 <Slereah> I think it's mostly the fault of the Love Machine 9000.
06:53:47 <Slereah> Well, actually, there's exactly 5 states for the brackets.
06:53:57 <Slereah> But other than that, it's usually 2.
06:54:30 <Slereah> One state to do the instruction, one to go back on the code and increment it.
06:57:08 <dbc> Ah. Increment it, meaning move the code head right?
06:57:32 <Slereah> That's the state g in the code.
07:05:39 <Slereah> I should put the unicode-like version online, too.
07:26:02 -!- calamari has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:59:18 -!- GreaseMonkey has quit ("Welcome to 2008. I will be your tour guide.").
10:12:38 <GregorR> http://www.codu.org/wiki/?title=Hydra // card game we invented at the New Years party
10:45:09 -!- slereah_ has joined.
10:57:53 -!- Slereah has quit (Read error: 110 (Connection timed out)).
12:09:24 -!- oerjan has joined.
13:24:13 -!- Hiato has joined.
13:24:28 -!- RedDak has joined.
13:29:58 <Hiato> cool, same here, after last night ;)
13:31:09 <oerjan> oh yeah, happy new year
13:31:46 <Hiato> PS: 8tt.org is back so Full 0 now sits back at http://www.full0.8tt.org
13:34:55 -!- Hiato has quit ("Leaving.").
13:50:29 -!- jix has joined.
14:48:06 <oerjan> hey, he didn't say it was an offline party...
14:49:00 <oerjan> hm actually GregorR has to be sociable. he has to show off his hats after all...
14:50:39 <slereah_> Well, he could send photos on the interwebs!
15:11:11 -!- jix has quit (Read error: 145 (Connection timed out)).
15:12:05 -!- jix has joined.
15:25:34 -!- biribau has joined.
15:26:18 <biribau> hi, prolog basics questions have site here?
15:33:39 -!- oerjan has quit ("Dinner").
15:39:07 -!- biribau has left (?).
15:47:35 -!- Sgeo has joined.
15:52:33 * Sgeo threatens to not work on PSOX if no one talks
16:01:06 -!- slereah_ has changed nick to Slereah.
16:28:12 <oklopol> <ehird> wow, er, that's impressive.. i didn't know you could patternmatch lambdas
16:28:12 <oklopol> <ehird> oklopol: you'd like that!
16:36:22 <Sgeo> ((?:[^\x00]|\x00{2}(?:.|\Z))*)(\x00.*)? is the most important regex in PSOX?
16:37:38 <Sgeo> Can that regex be made more efficient?
17:07:02 -!- Hiato has joined.
17:08:09 <Sgeo> ((?:[^\x00]|\x00{2}(?:.|\Z))*)(\x00.*)?
17:08:46 <Sgeo> That's the most important regex in PSOX
17:09:12 <Hiato> lol, regexp's are not my strong point :P (especially in Ruby)
17:09:18 <Hiato> Why, what does it do?
17:09:47 <Sgeo> breaks a line apart into the outputted text with 0x00 0x00 etc. and the command part with 0x00
17:10:03 <Hiato> oh yeah huh, ^\xoo
17:10:26 <Hiato> so, anything news, perhaps a version I can start meesing with?
17:11:38 <Hiato> meh, I hat tyops :P
17:12:23 <oklopol> x:xs can be used as a pattern matcher because a list can be represented as just one cons. a+b cannot pattern match because there's an infinite amount of conses for addition, 6=6+0=5+1=... now, if one were to introduce the concept of virtual cons cells into a language, and make a cons be a set of rules of dependence, so that an addition cell knows it's (result - b, result - a).
17:12:25 * Sgeo is working on the psox.types module
17:12:45 <oklopol> this way you could pattern match like the haskell n-1 pattern, but in a more sophisticated fashion.
17:13:11 <oklopol> well, haskell prolly has a much more sophisticated reason for that to work, but i don't know it, and i prefer my own ideas.
17:14:22 <Hiato> :), I generally prefer my own ideas too, over others that is. Some call it stubbornness ;) Oh, and I agree with Sgeo: ??
17:15:26 <oklopol> these would be virtual cells of course, so when doing a pattern match for 5 on (n+3), 5 would be converted to an addition cell as (result-b, 3), where b=3 = (2,3), so n=2
17:15:50 <oklopol> IF the conversion into an addition cons cell should fail, the pattern match simply would fail.
17:16:11 <oklopol> this would be correct at least in this case, since only numbers can be subtracted from
17:16:19 <Hiato> I'm still not quite with you... but I guess it's not aimed at me :) (Otherwise ti would be allot longer)
17:16:25 <Sgeo> Is this anything to do with PSOX? If so, please be warned that I don't have a drop of understanding of what you're talking about
17:16:51 <oklopol> but, you could also have the possibility to specify domains for which the conversion always works
17:17:13 <Hiato> is this part of the Graphica spec?
17:17:35 <oklopol> oh, right, in case in the final pattern, there were still cells that are defined in terms of other cells, the pattern itself would be incorrect, for example if you tried to pattern matchon (a+b)
17:18:08 <oklopol> although, that could just take a random cons cell that represents 5 as an addition.
17:18:41 <oklopol> sometimes, all that matters might be that you separate the object into *some* other objects that, when consed, result into the original object.
17:18:56 <oklopol> not in the case of numbers and addition, prolly, but with lists, for example.
17:19:08 <Hiato> Sgeo: is he talking to us?
17:19:30 <oklopol> this is very esolang-related, and not that high-level
17:19:50 <Hiato> sure, don't let me stop you
17:19:58 <Sgeo> If it's PSOX related, you are hereby REQUIRED to translate it into something that makes sense..
17:20:01 <oklopol> just /ignore me for a while in case not interested, this is just may way to clear my thoughts, if okay.
17:20:38 <oklopol> so, for instance quicksort's pivoting, pmatch the list into lpart++[pivot]++rpart
17:20:41 <Hiato> I will interject when (rather if) I have something to say
17:20:47 <oklopol> because all we want is *some* pivot
17:21:15 <oklopol> (++ lpart (++ [pivot] rpart))
17:21:36 <oklopol> if i didn't have this headache, i'd manually pattern match that
17:21:46 <oklopol> might be an interesting concept
17:22:04 <oklopol> but once again it's so clever yet simple it must already be in use.
17:22:08 <Hiato> er.. yes .. amm.. no .. whichever is more appropraite :)
17:22:18 <oklopol> well, not clever, but... fun?
17:23:07 <oklopol> sorry, was lost in my thoughts, so didn't read what you said between my messages
17:23:22 <oklopol> you didn't *get* that? in that case i'll happily explain
17:23:26 <Hiato> sure, no problem, and believe me, it wasn't important
17:23:28 <oklopol> i just assumed you don't care :-)
17:23:49 <Hiato> lol, I care, but don't *concentrate*
17:24:01 <oklopol> do you know what pattern matching is?
17:24:14 <Hiato> amm, well yes (I think)
17:24:40 <Hiato> as in "The cat ate the mouse" pattern would be "at' twice?
17:26:20 <oklopol> like, if you have the list [1,2,3]
17:26:33 <oklopol> that's basically (cons 1 (cons 2 (cons 3 nil)))
17:26:49 <Hiato> well, other than the cons, yes
17:27:08 <oklopol> it means (cons head-of-list tail-of-list)
17:27:14 <oklopol> where tail-of-list is usually the rest of the list
17:27:32 <Hiato> (with caution ;) )
17:27:45 <oklopol> now, let's define a function that takes the second element of a list and returns that *2
17:28:17 <oklopol> you could do it with L -> (tail tail List) * 2
17:28:26 <oklopol> where tail does (cons a b) -> b
17:28:47 <Hiato> lol, wait, thinking
17:28:59 <oklopol> think about the correct one, though :) the latter
17:29:06 <Hiato> ok, wait some more
17:29:12 <oklopol> OKAY, that's incorrect too, sorry
17:29:42 <oklopol> then return what's after ->
17:29:59 <Hiato> tail list of head is 2,3
17:30:02 <oklopol> could explain my code if i invent the notation on the fly...
17:30:39 <oklopol> for a more imperative version
17:31:27 <oklopol> L -> ListTail = tail List; SecondHead = tail ListTail; return SecondHead*2
17:31:33 <oklopol> although you already got it.
17:31:39 <oklopol> i just wanted to write that for some reason
17:32:22 <oklopol> okay, no the idea of pattern matching is, instead of explicitly taking the *head* of a list, we just take the list in as if it were already spliced into a head and a tail.
17:33:11 <oklopol> (: 1 (: 2 (: 3 Nil))), ":" is cons here, it's just a shorter word so i don't have to type cons, although this explanation is longer than all the conses i've ever written, so it is pretty useless.
17:33:40 <oklopol> so, we define the function as (: A (: B L)) -> 2*B
17:33:51 <oklopol> so, instead of just putting the param into a variable
17:33:59 <oklopol> we have a pattern we match for the parameter
17:34:14 <oklopol> and inside the pattern, there are variables, that hold the parts of the parameter.
17:34:20 <Hiato> L being significant of the rest of the list?
17:34:32 <oklopol> this works because most data can be, and is often represented by a tree.,
17:35:00 <Hiato> and somewhat Alpha Bet Pruning
17:35:18 <oklopol> BFStmt=+|-|>|<|[BFStmt]|,|.
17:35:31 <Hiato> what the hell is that
17:35:38 <Hiato> never seen it like that
17:35:45 <Hiato> BFStmt=+|-|>|<|[BFStmt]|,|.
17:35:51 <Hiato> you claim it to be alphabeta
17:36:05 <oklopol> | was jsut my way to separate possibilites for a branch
17:36:18 <oklopol> actually a pretty standard way
17:36:36 <Hiato> well, its pruning, like minimaxing
17:36:37 <oklopol> anyway, L was the rest of the rest of the list.
17:37:29 <oklopol> (: A (: B L)) -> 2*B can be written A:B:L->2*B if we notate : as infix and right grouping, right
17:38:02 <oklopol> so... we pattern match as 1->A, 2->B, 3:Nil->L
17:38:30 <oklopol> actually, the cons representation is much clearer when you pattern match, just felt it'd look bad if i wrote it on irc.
17:38:34 <Hiato> so, actually L = 1->A, 2->B, 3:Nil
17:39:13 <oklopol> because A and B take the first two elements
17:39:37 <Hiato> just that the 3:NIL->L got me
17:40:20 <oklopol> in (: A (: B L)) -> 2*B, (: 1[place of A] (: 2[Place of B] (: 3 Nil)[place of C]))
17:41:04 <Hiato> (: 3 Nil)[place of C] surely place of L
17:41:13 <oklopol> anyhow, do you see what the function (4+A) -> A*2 would do given 2 as a parameter?
17:41:35 <oklopol> i'm very bad at keeping the details right
17:42:17 <oklopol> it cannot actually be executed as straightforwardly as the list one, because a list IS (cons Head Tail), while a number is NOT (+ A B), but just a number.
17:42:51 <Hiato> was my third guess
17:43:05 <oklopol> (4+A) find such A that (4+A) = param, basically.
17:43:33 <oklopol> just as the pattern match (: A (: B L)) meant "find A, B and L so that (: A (: B L)) equals the parameter"
17:44:03 <Hiato> ooh, ok, im starting to see the light now
17:44:25 <oklopol> this is a trivial concept, but *very* interesting if you ask me
17:44:41 <Hiato> I'm glad I learnt it :)
17:44:42 <oklopol> not trivial as in "lol you should know it already", i meant like simple
17:45:01 * Sgeo fails to understand Lispy stuff
17:45:19 <Hiato> no worries Sgeop, it took me this long to get it :)
17:45:26 <oklopol> Sgeo: (Function Argument1 Argument2 ... ArgumentN)
17:45:42 <oklopol> where arguments can be sexps too.
17:46:00 <oklopol> (sexp is (A B C ... N) that is.)
17:46:43 <oklopol> basically, in lisp you take the program, which is a list (A B C .. N), you evaluate B, C.. N first, then evaluate the function A with the evaluated arguments.
17:46:58 <oklopol> B.. N are evaluated just like in A, in a recursive fashion
17:47:06 <oklopol> also, i suck at explaining right now, sorry.
17:47:38 <Hiato> :) No worries, teaching fools is a great gift (with reference to me, for the fools part)
17:47:47 <oklopol> anyway, Hiato: do you see why pattern matching for *any* pattern would be impossible?
17:47:57 <oklopol> i mean, for operators you can define yourself.
17:48:21 <Hiato> yes, infinte possibilties
17:48:41 <oklopol> in the list case, you can do A:B unambiguously
17:49:02 <oklopol> and with most operators, you can pattern match on some elements
17:49:26 <oklopol> and [1,2,3,4,5] -> [1,2,3]++A
17:49:38 -!- RedDak has quit (Remote closed the connection).
17:50:02 <oklopol> in there, A++B could do any split for a list, BUT if you do [1,2,3]++A you only get one list.
17:50:27 <Hiato> ambiguity in pattern search
17:50:38 <Hiato> results in multiple possibilites
17:50:47 <oklopol> often, that is true for binary operators, : just happens to be an example of an operator where you can do it with two vars
17:51:00 <oklopol> but, that was not my point
17:51:14 <oklopol> a pattern should never have these ambiguities.
17:51:41 <oklopol> it's the programmer's job to make them correct, and such that there is only one way to cut the object pmatched.
17:53:16 <oklopol> we can make a function, whose converse makes us solve the halting problem or something.
17:53:56 <oklopol> and, often functions are only easy to do one way, even though they actually have just one converse.
17:54:18 <oklopol> @ is a function that takes a list of primes, and multiplies them.
17:54:34 <Hiato> no need to go urther
17:55:02 <oklopol> it multiplies the elements
17:55:10 <Hiato> I meant an easy one way thingy
17:55:40 <Hiato> the other way areound
17:55:46 <oklopol> modulus doesn't have an unambiguous converse :)
17:55:47 <Hiato> but you get what I'm saying
17:56:05 <Hiato> with the halting problem
17:56:22 <oklopol> it's the programmer's job to ensure there always is an unambiguous converse for the function we are cutting.
17:56:40 <oklopol> function we are pattern matching with
17:56:41 <Hiato> ok, anyway proceed
17:57:02 <oklopol> so, no if you have *any number*, you can always do the pattern match @L
17:57:14 <oklopol> and it's always unambiguous.
17:57:22 <Hiato> limited selection of primes
17:57:32 <Hiato> who's product is Number
17:57:41 <oklopol> now, @ does multiplication, it's inverse does factorization.
17:58:14 <oklopol> my idea was just to inject into an operator knowledge about it's reversibility
17:58:42 <Hiato> so, given @, you idea would be to say @(fatcorise)
17:59:19 <Hiato> ! being, say the modulus function
17:59:24 <oklopol> i'll show how it's used, not sure you got me fully here
17:59:27 <Hiato> rather !(irreducibnle)
17:59:41 <Hiato> provide an example
17:59:50 <Hiato> then I''l be able to say whether I understood or not
18:00:56 <oklopol> well, basically, you could do a factorizing function as follows: first the multiplication of primes: L :: [Prime] -> Int = L -> Product L
18:01:12 <oklopol> let's say our language defines a number type Prime
18:01:16 <oklopol> which represents any prime number.
18:01:33 <oklopol> now, the factorizing function would be "@ L -> L"
18:01:51 <oklopol> @ :: [Prime] -> Int = L -> Product L
18:02:11 <oklopol> @ L means multiply the primes in L to get the number they represent.
18:02:30 <oklopol> so, @ L as a *pattern match* means find such L that @ L is the parameter.
18:02:46 <oklopol> now, since the parameter is an integer, and @ multiplies a list of primes, it would factorize the number.
18:02:52 <Hiato> so kind of linear equationns
18:03:21 <oklopol> were we to make @ also check that the list it's used on is sorted, @ L would automatically return a sorted list of prime divisors.
18:03:21 <Hiato> I think I get thwe whole plot
18:03:48 <Hiato> so, we can't make a universal patten mathcer
18:03:49 <oklopol> now, this is all my own thinking, i don't know if others think about patterns that much.
18:03:58 <Hiato> it has no way of knowing what the inverse is??
18:04:12 <oklopol> that is the basic problem, yes
18:04:16 <Hiato> the inverse procedure
18:04:28 <Hiato> and congratulations to you :D
18:04:39 <oklopol> there is a way to find a problem whose inverse is the halting problem
18:05:06 <oklopol> it's just half the stuff i *taught* you i made up on the fly, i don't yet have that good an intuition on the general pattern matching.
18:05:12 <oklopol> i have no idea how to construct it.
18:05:16 <Hiato> (PS: THis is actually interesting now that I understand it :) )
18:05:32 <oklopol> perhaps i should add it into graphica........
18:05:39 <Hiato> that would be nice
18:05:48 <Hiato> not sure how it would come into play
18:05:52 <oklopol> actually, i was thinking, i'd make an esolang that provides automatical converses.
18:05:55 <Hiato> unlence referencing node trees
18:06:10 <oklopol> and put it in the "super-turing" category
18:06:13 <Hiato> that would be aweosme
18:06:28 <Hiato> then simply give it a function garunteed to terminate
18:06:33 <Hiato> and you solve the halting problem
18:07:10 <oklopol> yeah, it could be made a *best-effort* compiler.
18:07:29 <oklopol> you can actually do stuff like A+3=7 in prolog too.
18:07:30 <Hiato> would be insanely hard though
18:07:37 <oklopol> that just hangs, but it's there.
18:07:44 <oklopol> well yeah, it's just it doesn't find it :)
18:07:58 <oklopol> but, the language allows you to ask it questions it cannot answer.
18:08:03 <Hiato> but I doubt you could go x^2 - 4 = 0
18:08:08 <oklopol> so, mine isn't more superturing than prolog.
18:08:25 <oklopol> you can't, and you can't really go A+5=0 either, since it just hangs...
18:08:33 <Hiato> if it could reduce things down to simpler elements
18:08:40 <Hiato> which are by default reducabel
18:08:48 <Hiato> and then solves for, or pmatches
18:09:09 <oklopol> indeed, i didn't even realize it'd automatically solve equations
18:09:10 <Hiato> so take x^2 - 4 =0
18:09:33 <oklopol> since i'm more interested in trees and graphs than numbers, usually
18:09:37 <Hiato> it would still be hellkish powerful
18:09:56 <Hiato> you get it working in lists
18:10:04 <oklopol> well, given that the language would *guarantee* that it find the inverse, yes, it would be powerful :)
18:10:09 <Hiato> that it will be able to do anything
18:10:28 <Hiato> what you waiting for, get cracking :)
18:10:50 <oklopol> is Pattern match -> Variable
18:10:57 <Hiato> but anyway, I still say find things that are unambiguously reducable, and redice them, then pmatch, then build back up
18:10:58 <oklopol> you cannot do *any* computation!
18:11:23 <oklopol> well, any computation in the result part.
18:11:37 <Hiato> simply proven by uncertainty principle ;)
18:11:46 <oklopol> actually, you could just have the pattern match, and have the result be a variable with # prepending it or something :)
18:12:05 <Hiato> the yopu can do mathematics in it :)
18:12:31 <Hiato> but that would be more difficult to execute
18:12:31 <oklopol> that would actually be *really* esoteric, and actually i'm starting to feel this is quite brilliant! AND then i realize i'm making prolog ;)
18:12:47 <Hiato> Well, not entirely ;)
18:13:02 <Hiato> prolog dies when it sees a + 5 =1
18:13:03 <oklopol> well, prolog, but with a very different idea.
18:13:17 <Hiato> I see real purpose for this creation of yours
18:13:20 * Sgeo keeps working on psox.types
18:13:22 <Hiato> beyond esotericality
18:14:06 <Hiato> a language which could solve functions, or pmatch, as the case may be
18:14:15 <Hiato> and then, naturally calculate inverses
18:14:24 <Hiato> that would be soo powerful
18:14:31 <oklopol> hmmmm, actually, it would lessen it's prologity, if you could help the language with the inverse, like specify that A+B=C --> A=C-B, B=C-A
18:14:48 <Hiato> call them, helper functions
18:14:56 <Hiato> then we get towards AI
18:15:07 <oklopol> every function = helper annotations + pattern match
18:15:14 <Hiato> (wonders if the labgauge could solve for : itself)
18:15:56 <oklopol> i'll start right after i've looked at the other channels, i was highlighted at about the time i wrote the initial idea on the chan ;)
18:16:09 <oklopol> which was like an hour ago xD
18:16:22 <Hiato> please please please, keep me updated on this one
18:16:48 <Hiato> (Oh, and this will also provide the freedom of sytax choice, removing all the funcky prolog)
18:18:09 <Hiato> *** A language is born ****
18:18:37 <oklopol> a chick told me to go fuck her, bluntly put :-)
18:19:15 <oklopol> i'd actually prefer doing the language, to be honest, but i'm too polite to say no
18:19:25 <oklopol> and that was not a joke :\
18:19:49 <Hiato> and just take some paper with
18:20:01 <oklopol> okay, see ya, i'll keep ya updated ->
18:20:18 <Sgeo> oklopol, waiait, on IRC?
18:28:56 <Hiato> Well, just grabbed Menuet OS 0.74b so gonna look around, be back late
18:29:03 -!- Hiato has left (?).
18:30:42 <oklopol> Sgeo: she asked that on irc, yes; the sex will prolly be the offline-type, though.
18:31:25 <oklopol> also, cya, 'll keep ya up to date on the lang ->
18:32:18 * pikhq laughs his ass off
18:34:11 -!- lby has joined.
18:34:25 -!- lby has quit (Client Quit).
18:39:52 <Sgeo> "This is a python program that can convert bianry number( binary is a language that computers use to comunicate with other) to a normal digital number and the other way around."
18:39:55 <Sgeo> http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496778
18:40:01 <Sgeo> Excuse me while I hurt someone
18:45:40 <Slereah> Hey Sgeo, 010010101000101010111
19:04:24 -!- ehird` has quit (Success).
19:28:21 -!- faxathisia has quit ("Leaving").
19:29:06 <pikhq> Sgeo, that program is just awful.
19:34:59 -!- Hiato has joined.
19:43:02 <Hiato> any notable progress Sgeo?
19:43:11 <Sgeo> Working on types.py
19:43:28 <Hiato> would you say Python is a good language to learn?
19:43:34 <Hiato> better than Perl or C, for example
19:48:08 <Sgeo> Though I might be biased
19:48:33 <Hiato> Well, that's impossible as I asked for your opinion ;)
19:50:14 <Hiato> Any funky esolangs that you specifically enjoy?
19:50:26 <Hiato> Just trying to get some ideas, I want to design another lang
19:50:47 <Hiato> because the unnamed one is way to hard to programme in
19:50:55 <Hiato> and Full 0 is way to easy :)
19:55:06 <Hiato> a man of few words :P
19:55:08 -!- calamari has joined.
20:07:05 -!- oerjan has joined.
20:13:31 -!- RedDak has joined.
20:37:33 <Sgeo> Hi calamari and oerjan and RedDak
20:38:06 <oerjan> and Happy New Year to anyone i haven't said it to yet
20:58:34 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
21:18:16 -!- RedDak has joined.
21:18:44 <Sgeo> FNUMs are giving me a headache
21:19:19 <Sgeo> and so will LNUMs
21:28:50 <Hiato> "Hello, World!" in my (as of yet) unnamed esolang:
21:28:50 <Hiato> {{>>~~~~{-<}~~~~~~~~~{-<-<}<<}</(<<<){[<]}:>:{>>{~~~~~~~~
21:28:50 <Hiato> {<}~{>}}<<}\~>{{~{v}}>>>v{~}^<<<}/(<<<){[<<]}:>:{>>{~~~~~
21:28:50 <Hiato> ~~~{<<}~{>>}}<<}\~{>>{vvvvvvvv~~~~~~~~~~~~~~~}<<}~{>>{vvv
21:28:50 <Hiato> v~~~~~~~~~~~~~}<<}~{>>{^^^^^^^^^^~}<<}~{>>{v~~~~~~~{{<<}~}
21:28:52 <Hiato> v{~}vvvvvvv{~{>>}}^^^^^^~~~{{<<}~}vvvv{~{>>}}v~~~}<<}~<{{^
21:28:54 <Hiato> ^^}}~{>>{vvvvvv~{{<<}~{>>}}^^^^^^^~~~~~~~~~~~{{<<}~{v>}}^^
21:28:56 <Hiato> ^^^^}}/{{()}}{[<<<<]}:>:{{~v}}\}
21:34:12 -!- RedDak has quit ("I'm quitting... Bye all").
21:35:02 -!- RedDak has joined.
21:50:35 <Hiato> alrighty, well cheers all
21:50:58 -!- Hiato has left (?).
22:05:16 <Sgeo> pikhq, Overand oklopol anyone else who cares, is it ok if PSOX.py is 2.5?
22:05:25 <Sgeo> relies on Python 2.5 I mean?
22:06:12 <pikhq> I think I have Python 2.4 ATM. . .
22:09:48 -!- Dagide has joined.
22:12:51 <Sgeo> Actually, n/m maybe
22:14:50 -!- RedDak has quit (Read error: 113 (No route to host)).
22:35:33 -!- Sgeo has quit (Connection timed out).
22:36:14 -!- Sgeo has joined.
22:36:38 <Sgeo> Would anyone miss the extended function names "feature"?
22:48:04 -!- GreaseMonkey has joined.
22:48:40 <Sgeo> Hi GreaseMonkey
22:49:36 <GreaseMonkey> {{print($1);}("Hello ".concat($1,"!"));}("Sgeo");
22:50:08 -!- Dagide has quit (Remote closed the connection).
22:57:00 <Sgeo> "Removing extended functions to make my life easier.. yes, I'm being mean …"
22:58:32 <Sgeo> Also, all the implementations of the domains are going to go right in the same directory with everything else
23:02:40 <Sgeo> pikhq, you awake?
23:02:43 <Sgeo> Anyone else awake?
23:05:01 <pikhq> No, I'm not awake. ;)
23:22:55 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/impl/psox/domain.py