00:10:20 <ehird> oklofok: no built-in-function type? XD
00:10:51 <ehird> oklofok: specialcasing atoms, thingy
00:10:58 <ehird> oklofok: shouldn't / be a built-in function?
00:11:00 <ehird> that sends the atom off
00:11:26 <oklofok> the dispatch is just plain oklotalk logic
00:11:39 <oklofok> as i said, it's not (func arg arg)
00:11:52 <oklofok> the expressions are asked to perform the operation, one by one
00:12:00 <oklofok> the one who wants to, does it
00:12:12 <oklofok> and if no one wants to do it, the first one is asked to
00:12:31 <oklofok> and yes, "wanting" is the official term
00:20:02 <ehird> oklofok: so, it asks $/ to $/ with $/
00:20:05 <ehird> then asks $/ to $/ with $/
00:20:08 <ehird> since neither wants to do it
00:20:12 <ehird> it asks $/ to $/ with $/
00:20:18 <ehird> and it says 'oh fuck it' and returns itself
00:20:34 <oklofok> yep, it should actually try all three, but i disabled that for this version, because currently only atoms don't want to evaluate
00:20:39 <oklofok> usually, that's just what you want
00:21:00 <oklofok> but the feature is useless atm
00:21:20 <oklofok> it won't be once i add... well, querying what wants to evaluate
00:21:34 <oklofok> but has to be done in order to get done, anyway
00:21:50 <ehird> oklofok: so {} is just a '
00:22:10 <ehird> and doers can want to do some things (isomorphic to function calls)
00:22:17 <ehird> and not do others (unique to oklotalk)
00:22:29 <ehird> and that's why you can use {} as a function
00:22:34 <oklofok> things don't want to do everything
00:22:43 <oklofok> i mean, 1 doesn't want to add a complex to itself
00:22:44 <ehird> 'and not do others'
00:22:54 <oklofok> which is why something like __radd__ can be made
00:23:08 <oklofok> actually i'm not sure i understood
00:23:58 <ehird> oklofok: {...} creates a 'thing'
00:24:02 <ehird> things have a few properties:
00:24:24 <ehird> - they can 'do' some things, based on whether they match one of several patterns given (pattern matching is definable and thus TC)
00:24:38 <ehird> - everything that they don't explicitly want to do, they don't, and cascade
00:24:52 <ehird> the 'actions' inside
00:25:02 <ehird> so {(-> [a b] {...})}
00:25:09 <ehird> the inner 'thing' can access the stuff given
00:25:14 <ehird> and the outer 'thing' acts like a function
00:26:03 <oklofok> it's really about whether a thing will evaluate any expression given a certain argument
00:26:27 <oklofok> so if a function starts with an action, it will want all args
00:29:32 <oklofok> like {outn "an function was entered"; ptrn -> smth} will always want
00:30:10 <pikhq> Somehow, it amuses me greatly that my math teacher from last year has offered me a ride to the Shadowmoor prerelease.
00:30:36 <pikhq> Shadowmoor is the next Magic: The Gathering set.
00:30:40 <ehird> oklofok: oh you can do that?!
00:30:59 <ehird> :: (= myId {outn "boo"; (-> x x)})
00:31:01 <pikhq> And a prerelease is a tournament where you're given a bunch of cards from the upcoming set to build a deck with.
00:31:25 <oklofok> 1. no output in oklotalk--, it goes in my terminal
00:31:38 <oklofok> 2. no ; in oklotalk--, just space to separate expressions
00:32:01 <oklofok> {outn "boo"; (-> x x)} works
00:32:09 <oklofok> {(outn "boo") (-> x x)} works
00:32:18 <oklofok> but you can't show it, because no side-effects are visible
00:33:22 <oklofok> :: (= x {(-> n {(-> [$set n] n) (-> $get n)})})
00:33:48 <ehird> i'm going to make a linked list
00:34:01 <oklofok> so, we have a pointer here
00:34:27 <ehird> oklofok: is just (-> [$pb] ...) ok?
00:34:30 <oklofok> :: ({(set test 8) (-> n (* n 3))} 5)
00:37:29 <ehird> oklofok: ok, define $pb message to me exactly
00:37:34 <ehird> what is sent [$pb ???]
00:37:36 <oklofok> :: (= ptr {(-> n {(-> [$set n] n) (-> $get n)})})
00:37:37 <ehird> and what should i return
00:38:00 <oklofok> when something is pattern matched on an application of the form (x y z)
00:38:03 <ehird> does the 'n' override the upper scopes 'n'?
00:38:10 <ehird> just continue answering
00:38:16 <oklofok> the message [$pb x] is sent to the object.
00:38:28 <oklofok> and if it returns a list with 2 elems, those are put into y and z
00:40:24 <oklofok> i'm fairly sure i've done all scoping *well*, at least it usually seems to work whatever i do
00:40:32 <ehird> :: (= cons {(-> [h t] {(-> [$pb cons] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t)})})
00:40:40 <ehird> :: (= test (cons 1 2))
00:40:55 <ehird> :: (setcar test 3)
00:41:22 <ehird> oklofok: oklotalk is cool. could use some nicer syntax though, yeah ;)
00:41:27 <oklofok> because that's the standard
00:41:34 <ehird> i won't do indexing
00:41:36 <ehird> it's just a cons cell
00:41:38 <oklofok> and we'll try quicksort :D
00:41:43 <ehird> you can treat it like a list though
00:42:05 <ehird> oklofok: can you define setters?
00:42:11 <ehird> you can override FOO
00:42:21 <ehird> you can define a setter for (car x)
00:42:30 <ehird> presumably, it would be like $pb
00:42:36 <oklofok> that isn't done yet, = only does vars
00:42:42 <oklofok> but that's just because i'm lazy
00:42:48 <ehird> but i dunno what would be returned
00:43:12 <ehird> (= (X Y) Z) -> (X [$= Y Z])
00:43:39 <ehird> oklofok: what is the syntax I use for indexing?
00:44:21 <oklofok> it might be that the quicksort doesn't work if the list isn't primitive...
00:44:27 <oklofok> depends on how i've done filter...
00:44:34 <ehird> oklofok: you can implement filter in oklotalk
00:44:44 <oklofok> and would be much cooler too
00:44:47 <ehird> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1)))})})
00:44:54 <ehird> oklofok: ok, try quicksort
00:46:06 <ehird> oklofok: just try it
00:46:19 <ehird> oklofok: how do i trigger an error?
00:46:35 <ehird> oklofok: like this:
00:46:46 <otobot> An error: Empty application.
00:46:51 <ehird> oklofok: 'An error:'
00:47:04 <ehird> you should add that, sometime
00:47:16 <oklofok> well, i could, in oklotalk--
00:47:49 <oklofok> but it's not very oklotalky, unless you've stored the continuation for the return somewhere
00:48:02 <ehird> oklofok: it should be oklotalky
00:48:06 <oklofok> i guess you can just implement that without explicit continuations
00:48:08 <ehird> since nothing ever fails
00:48:11 <ehird> so it's really hard to debug
00:48:13 <ehird> also, code doesn't get shorter
00:48:19 <ehird> since you have to manually check for errors
00:48:27 <ehird> and yeah, you can just do it with exceptions
00:48:35 <ehird> which are a special, downwards-only, one-shot form of continuations
00:48:51 <oklofok> well i could do that just with a simple *python exception*, in like a few lines
00:49:02 <ehird> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f)})
00:49:16 <oklofok> but perhaps later, right now i need to add a thing to get filter to work
00:49:38 <ehird> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
00:49:50 <oklofok> you can't dispatch on anything except what the object matches on
00:50:03 <ehird> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
00:50:13 <ehird> :: (length (cons 1 (cons 2 nil)))
00:50:27 <ehird> oklofok: i think i might be the best oklotalk coder next to you
00:50:49 <ehird> oklotalk is FLEXIBLE
00:51:10 <ehird> oklofok: make it try ALL PERMUTATIONS
00:51:12 <oklofok> it will work in actual oklotalk :D
00:51:17 <oklofok> that's an implementation defect.
00:52:05 <oklofok> about permutations... pattern matching will actually, when excountering an application as a pattern, first ask the function that is used for splitting if it's some special thing
00:52:20 <oklofok> you can do for instance (* n) for matching any number of n's in a list
00:52:36 <ehird> try all permutations
00:52:44 <oklofok> you can have patterns in a certain kind of list
00:53:01 <oklofok> well... why not, why not xD
00:53:17 <oklofok> you know when you have lots of types
00:53:32 <oklofok> if you have a program with type checks and such
00:53:48 <oklofok> so you could basically have the program just guess what arg is what based on types
00:54:05 <ehird> oklofok: however, i still think you need a propogating error message mechanism
00:54:08 <oklofok> (prm [(int x) (str y) (lst z)])
00:54:09 <ehird> oklotalk's crazy ideas are fun
00:54:13 <ehird> but if you are actually gonna write something
00:54:18 <oklofok> that will match them in any order
00:54:26 <ehird> c has tons of fun because it does not have exceptions
00:54:31 <ehird> there's a global variable errno
00:54:35 <ehird> and everything sets it if it dies
00:54:38 <oklofok> propogating error messages?
00:54:40 <ehird> so you have to check errno after most calls
00:54:49 <ehird> oklofok: if you don't handle them, they bubble up the call stack
00:55:12 <oklofok> oklotalk should just allow you to step out of the evaluation, without actually even using continuations or anything
00:55:34 <oklofok> you can just move in the parse tree up to a try or something
00:55:41 <oklofok> i've written some fun thingies with this
00:56:01 <oklofok> heh, oklotalk has so much shit...
00:56:13 <oklofok> ehird: well yeah, exceptions
00:57:00 <oklofok> that "stepping a level up" can be used for something like define-syntax
00:59:20 -!- ehird has quit ("This computer has gone to sleep").
01:00:14 -!- otobot has quit (Remote closed the connection).
01:01:45 -!- otobot has joined.
01:03:44 <Sgeo> " Usage: NOTICE <nick/channel> <message>, sends a notice. Notices are a type of message that should be auto reacted to" isn't that exactly wrong?
01:05:03 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst {(f h)})) t) (+ [h] (' f t))]) (-> [f (: h t)] (+ [h] (' f t)))})
01:05:18 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:06:40 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t) (+ [h] (' f t))]) (-> [f (: h t)] (+ [h] (' f t)))})
01:06:43 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:08:46 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:08:51 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:09:00 <otobot> An error: Var instance has no attribute 'call'
01:09:59 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:10:05 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:10:07 <otobot> An error: Var instance has no attribute 'call'
01:11:20 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:11:59 -!- otobot has quit (Read error: 104 (Connection reset by peer)).
01:12:20 -!- otobot has joined.
01:12:58 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:13:06 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:13:09 <otobot> An error: Atm instance has no attribute 'call'
01:14:21 <oklofok> :: ({(-> (tst {(> 3 _)}) 0)} 5)
01:14:32 <oklofok> :: ({(-> (tst {(< 3 _)}) 0)} 5)
01:16:44 <oklofok> hoh, that's actually a pretty bad flaw.
01:20:35 -!- wildhalcyon has quit ("ChatZilla 0.9.81 [Firefox 2.0.0.13/2008031114]").
01:24:55 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:25:02 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:25:07 <otobot> An error: Atm instance has no attribute 'call'
01:30:35 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:30:43 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:30:45 <otobot> An error: global name 'self' is not defined
01:31:06 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})
01:31:14 <oklofok> :: (flr {(< _ 3)} [1 2 3 4 5])
01:31:16 <otobot> An error: global name 'self' is not defined
01:31:57 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})(flr {(< _ 3)} [1 2 3 4 5])
01:31:59 <otobot> An error: Atm instance has no attribute 'call'
01:32:53 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))})(flr {(< _ 3)} [1 2 3 4 5])
01:35:04 <Sgeo> I'd understand "oklobot" but otobot?
01:36:10 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t))})(flr {(< _ 3)} [1 2 3 4 5])
01:36:19 <oklofok> :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t))})(flr {(< _ 3)} [1 2 3 4 5 0])
01:37:32 <oklofok> :: (= qs {(-> [] []) (-> (: h t) (+ (qs (\ {(< _ h)} t)) (+ [h] (qs (\ {(>= _ h)} t)))))})
01:37:48 * Sgeo watches all this go way way way over his head
01:38:08 <oklofok> doesn't work with duplicates? 8|
01:38:33 <oklofok> :: (= qs {(-> [] []) (-> (: h t) (+ (qs (ftr {(< _ h)} t)) (+ [h] (qs (ftr {(>= _ h)} t)))))})
01:38:40 <otobot> An error: Atm instance has no attribute 'call'
01:38:41 * Sgeo doesn't know either QuickSort or Oklotalk
01:39:12 * Sgeo also needs a Python project to work on
01:39:21 <oklofok> Sgeo: oklotalk is a language of mine
01:39:29 <oklofok> and it is heresy not to know quicksort
01:39:29 <Sgeo> oklofok, I knew that
01:39:42 <Sgeo> (I meant, that oklotalk's yours)
01:40:04 <Sgeo> What's wrong with not knowing quicksort?
01:40:22 <oklofok> that i've known it so long i can't accept others not knowing it, mostly
01:41:05 <oklofok> it's like you would think someone is an idiot for not being able to solve 5x2 + 5x - 6 = 0, it's not something you often need, just known it forever, hard to understand some might not
01:41:44 <oklofok> (except that is actually taught to everyone, unlike quicksort)
01:43:41 <oklofok> Sgeo: i do think you should learn the most popular algos if you want to be taken seriously at a programming channel
01:44:37 -!- adu has joined.
01:49:01 <Sgeo> oklofok, meh, I guess
01:49:45 <Sgeo> Although do I really need to know e.g. quicksort in order to be able to program? I mean, it's already implemented by someone else.
01:50:30 <lament> he did say you should do it in order "to be taken seriously", not to be able to program
01:51:35 <oklofok> wtf filter *just worked*, how come it's broken now :D
01:52:49 <oklofok> okay, it works now... let's try ehird's list
02:00:30 <oklofok> a cons cell is a 2-tuple, whose first element is called car, and second cdr
02:00:42 <oklofok> and you usually use these functions to retrieve them
02:00:49 <Sgeo> I meant, what's ehird's cell?
02:01:07 <oklofok> (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:01:27 <Sgeo> Oh, ehird implemented a list in oklotalk?
02:02:08 <oklofok> although it doesn't fully work
02:02:56 <oklofok> oklotalk owns ass, i gotta say, when you look at how setcar and setcdr are done :D
02:03:26 -!- adu has quit (Remote closed the connection).
02:03:43 -!- adu has joined.
02:04:20 <adu> how are you
02:04:46 <Sgeo> ok. Looking at PSOX again, although no one else seems interested
02:05:37 <adu> whats PSOX?
02:05:44 <adu> i'm doing taxes
02:06:05 <Sgeo> http://esolangs.org/wiki/PSOX
02:06:31 <Sgeo> It's a layer that goes between stdio and esolang interpreters for esolangs that can only do stdio
02:06:49 <calamari> anyone remember the url to Gregor's website?
02:07:20 -!- oklofok has changed nick to oklopol.
02:12:38 <adu> I've been thinking about something like that
02:13:37 <adu> like you know, most languages go on the top (compiled to lower language) or on the bottom (virtual machine, assembly, etc)
02:13:47 <adu> I wonder how many languages take the middle approach
02:18:07 <oklopol> anyway, damn ehird for going to sleep
02:18:08 <adu> :: something
02:18:12 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:18:34 <oklopol> the filter function, takes a func and a list, filters elements the func returns false for
02:18:46 <oklopol> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
02:19:04 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:19:12 <adu> :: (string-ref "Hello" 1)
02:19:25 <oklopol> :: (= list (cons 6 (cons 1 (cons 9 (cons 2 (cons 4 (cons 0 nil)))))))
02:19:53 <adu> what is it?
02:19:59 <oklopol> :: (= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})
02:20:33 <adu> thats not sorted
02:20:33 <calamari> I remember that Gregor had some scans of pages he wrote out while designing c2bf.. I wonder if they are still online someplace
02:21:03 <oklopol> i swear it worked a minute ago in my cli
02:21:59 <oklopol> reload might not work properly.
02:21:59 <adu> maybe it thinks "0" is "5" for some reason
02:23:19 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})(= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})(= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})(= list (cons 6 (cons 1 (cons 9 (cons 2 (cons 4 (cons
02:23:24 <otobot> An error: Application consists of 2 or 3 expressions.
02:23:29 <adu> :: (= quicksort done)
02:23:35 <adu> :: (quicksort)
02:23:44 <otobot> An error: Application consists of 2 or 3 expressions.
02:23:48 <adu> mine is so much better
02:23:58 <oklopol> okay, let's see what happens if i reload the whole bot
02:24:02 <oklopol> adu: yes, but your call is wrong
02:24:08 <oklopol> (quicksort) doesn't make sense
02:24:17 -!- otobot has quit (Read error: 104 (Connection reset by peer)).
02:24:37 -!- oktabot has joined.
02:25:41 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []}) (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)}) (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})}) (= list (cons 6 (cons 1 (cons 9 (cons 2 (cons 4 (co
02:25:43 <oklopol> does that come through? should end in (qs list)
02:25:43 <oktabot> An error: Application consists of 2 or 3 expressions.
02:26:15 <adu> :: (qs [1,2,3])
02:26:16 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []}) (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)}) (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:26:32 <adu> :: (qs [5,4,3,2,1])
02:26:35 <oklopol> :: (= list (cons 6 (cons 1 (cons 9 (cons 2 (cons 4 (cons 0 nil))))))) (= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []}) (qs list)
02:27:14 <oklopol> i'll make a list of rational numbers and sort it :D
02:27:20 <adu> :: (qs (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 nil))))))
02:27:27 <adu> no it doesn't
02:27:32 <oklopol> the gist being that the list type and the rational number class are both mde in oklotalk
02:28:00 <oklopol> hmph, i'll start fixing again then
02:28:21 <adu> are you sure you're implementing it properly?
02:28:30 <oklopol> :: (qs (cons 4 (cons 3 (cons 2 (cons 1 nil)))))
02:28:54 <oklopol> :: (= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})
02:29:43 <oklopol> :: (= qs {(-> (: h t) (+ (qs (\ {(< _ h)} t)) (+ [h] (qs (\ {(>= _ h)} t))))) []})
02:29:55 <adu> :: (qs (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 nil))))))
02:29:59 <oktabot> [(-> cdr t) (-> [setcar h] h) (-> [setcdr t] t) (-> [! 0] h) (-> [! n] (! t (- n 1))) (-> length (+ 1 (length t))) (-> car h) (-> cdr t) (-> [setcar h] h) (-> [setcdr t] t) (-> [! 0] h) (-> [! n] (! t
02:30:26 <adu> :: (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 nil)))))
02:30:44 <adu> :: [1 2 3 4 5]
02:30:53 <adu> :: [1, 2, 3, 4, 5]
02:31:06 <adu> :: (1 2 3 4 5)
02:31:07 <oklopol> adu: i changed the implementation, doesn't work for other than primitive lists now.
02:31:09 <oktabot> An error: Application consists of 2 or 3 expressions.
02:31:16 <oklopol> it seems the problem is my filter function
02:31:25 <oklopol> and application takes 2 or 3 expressions
02:31:47 <adu> I don't know anything about your lang
02:32:15 <adu> whats the diff between [1 2 3] and [1, 2, 3] ?
02:32:25 <oklopol> well do like ehird and just start coding in it... :D
02:32:43 <oklopol> god i hate that dood sometimes
02:32:44 <adu> I have 3 languages like that
02:32:52 <adu> who is ehird?
02:33:07 <oklopol> ehird is a guy who lives here
02:33:23 <adu> oklopol: so what does (,) do?
02:33:41 <oklopol> (,)? that's not a proper application
02:33:53 <adu> ok so what does it do?
02:34:11 <adu> ok, so what is an atom?
02:34:22 <adu> like a symbol?
02:34:26 <oklopol> a retarded string, somewhat
02:34:38 <adu> I like symbols
02:34:55 <adu> can I help with your language?
02:35:14 <oklopol> well you can help me by telling what didn't work, i forgot.
02:35:23 <adu> I know hundreds of programming languages
02:35:34 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:36:00 <oklopol> in that case i should be able to explain this to you in an instant
02:36:21 <adu> I can guess that -> is lambda
02:36:45 <oklopol> (-> ptrn expr expr expr...)
02:37:03 <adu> so I'm guessing [] is empty list
02:37:06 <oklopol> it kinda checks the pattern, and if it matches, it continues the evaluating to the expr's
02:37:19 <adu> so what is '
02:38:12 <adu> what is @?
02:38:25 <oklopol> (@ a b) matches on both a and b
02:38:33 <oklopol> the object that is matched
02:38:43 <oklopol> (first on b, then on a, actually)
02:39:07 <oklopol> :: (flr {(> _ 3)} [1 2 32 454 5])
02:39:29 <oklopol> :: (flr {(> _ 3)} (cons 1 (cons 4 nil)))
02:39:47 <oklopol> :: (flr {(> _ 3)} (cons 4 (cons 1 (cons 4 nil))))
02:40:04 <oklopol> :: (flr {(<= _ 3)} (cons 4 (cons 1 (cons 4 nil))))
02:40:19 <oklopol> wtf. there needs to be something wrong with it
02:40:48 <adu> :: (= fac {(-> 0 1) (-> n (* n (' fac (- n 1)))) []})
02:40:55 <adu> :: (fac 2)
02:40:58 <oktabot> An error: maximum recursion depth exceeded
02:41:35 <adu> :: (= fac {(-> [f 0] 1) (-> [f n] (* n (' f (- n 1)))) []})
02:41:39 <adu> :: (fac 2)
02:42:06 <adu> I have no idea
02:42:19 <oklopol> the first one was correct, apart from a small... defect
02:42:33 <adu> whats that?
02:42:42 <adu> oh ok, but you had it in yours
02:42:45 <oklopol> it's would be returned if neither pattern matched
02:42:57 <adu> whats the defect?
02:43:00 <oklopol> yes, that's for returning [] for the standard case
02:43:45 <oklopol> you can just recurse by (fac ...)
02:43:46 <adu> :: (= fac {(-> 0 1) (-> n (* n (' f (- n 1))))})
02:43:47 <oklopol> + making it easier for lambdas to recurse
02:43:48 <adu> :: (fac 0)
02:43:57 <adu> :: (fac 2)
02:43:59 <oktabot> An error: maximum recursion depth exceeded
02:44:27 <adu> should "f" be "fac"?
02:44:27 <oklopol> just do what you did, again, and it should work
02:44:43 <adu> :: (= fac {(-> 0 1) (-> n (* n (' f (- n 1))))})
02:44:45 <adu> :: (fac 2)
02:44:47 <oklopol> you are making the call (fac f (- n 1)) there
02:44:48 <oktabot> An error: maximum recursion depth exceeded
02:45:07 <oklopol> (fac ..) or (' ...) for recursion
02:45:09 <adu> i dunno, cuz you did it like that
02:45:15 <adu> ooooooooooo
02:45:22 <oklopol> f was the function to filter with, man :)
02:45:24 <adu> :: (= fac {(-> 0 1) (-> n (* n (' (- n 1))))})
02:45:27 <adu> :: (fac 2)
02:45:41 <adu> I made a program in oklkang
02:46:35 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:46:41 <oklopol> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
02:46:49 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:47:00 <oklopol> :: (= list (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 (cons 0 nil)))))))
02:47:10 <oklopol> :: (= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})
02:47:33 <oklopol> i'll reboot the bot again..
02:47:39 -!- oktabot has quit (Read error: 104 (Connection reset by peer)).
02:48:02 -!- oktabot has joined.
02:48:07 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:48:11 <oklopol> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
02:48:17 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:48:26 <oklopol> :: (= list (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 (cons 0 nil)))))))
02:48:31 <oklopol> :: (= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})
02:48:37 <adu> :: (= talk {(-> ["hi" x] "Why hello!") (-> ["bye" x] "Good bye!") []})
02:48:45 <adu> :: (talk ["hi" "Mr. roboto"])
02:48:52 <adu> :: (talk ["hi" "Mr. roboto"])
02:48:59 <adu> :: (talk ["bye" "Mr. roboto"])
02:49:51 <oklopol> how come that only works on my comp :D
02:50:01 <adu> i don't know
02:50:03 <oklopol> i just copypaste the code :D
02:51:48 <adu> what does flr do?
02:52:11 <oklopol> :: (flr {(< _ 3)} [1 2 3 4 5])
02:52:39 -!- oktabot has quit (Read error: 104 (Connection reset by peer)).
02:52:52 <oklopol> something is very wrong...
02:53:17 -!- oktabot has joined.
02:53:28 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:53:43 <oklopol> :: (= flr {(-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (' f t)) []})
02:54:09 <oklopol> :: (flr {(< _ 3)} [1 2 3 4 5])
02:54:21 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:54:26 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})
02:54:35 <oklopol> :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
02:54:53 <adu> what does + do?
02:55:05 <oklopol> :: (= list (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 (cons 0 nil)))))))
02:55:25 <oklopol> it doesn't have functionality
02:55:27 <oklopol> (+ 1 2) sends the object 1 the message [$+ 2]
02:56:06 <oktabot> An error: Atm instance has no attribute 'call'
02:56:15 <oklopol> okay, this is a bit spooky
02:59:12 <adu> :: (-> 1 2)
02:59:37 <adu> ya thats spooky
02:59:47 <adu> where did the f come from?
03:00:26 <adu> :: ({(-> 1 2) 0} 1)
03:00:35 <adu> :: ({(-> 1 2) 0} 2)
03:01:36 <adu> what does "tst" do?
03:03:29 <adu> :: (= filter {(-> [f (: (@ h (tst f)) t)] (: h (filter f t))) (-> [f (: h t)] (filter f t)) []})
03:04:14 <adu> :: (= qsort {(-> (: h t) (+ (qsort (filter {(< _ h)} t)) (+ [h] (qsort p(filter {(>= _ h)} t))))) []})
03:04:16 <oktabot> An error: Unmatching parens @ row 1.
03:04:33 <adu> (= qsort {(-> (: h t) (+ (qsort (filter {(< _ h)} t)) (+ [h] (qsort (filter {(>= _ h)} t))))) []})
03:04:38 <adu> :: (= qsort {(-> (: h t) (+ (qsort (filter {(< _ h)} t)) (+ [h] (qsort (filter {(>= _ h)} t))))) []})
03:04:48 <adu> :: (qsort [1 2 3 4])
03:08:58 <oklopol> umm... it seems nothing works now.
03:09:09 <oklopol> which is kinda weird, because i haven't really changed anything.
03:09:49 <oklopol> adu: it should test whatever is matched with given function, and fail if it returns $f
03:10:16 <oklopol> but... nothing works now, so wtf.
03:12:25 <oklopol> i think i see what's going on...
03:12:46 <oklopol> i'll fix it by removing a feature no one knows even exists.
03:13:59 <oklopol> :: (= flr {(-> [p (: (@ h (tst p)) t)] (outn "a") (+ [h] (' p t))) (-> [p (: h t)] (outn "b") (' p t)) (outn "c") []})(flr {(< 3 _)} [1 2 3 4 5 ])(= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
03:14:08 <oktabot> An error: Atm instance has no attribute 'call'
03:15:14 <oklopol> :: (= flr {(-> [p (: (@ h (tst p)) t)] (outn "a") (+ [h] (' p t))) (-> [p (: h t)] (outn "b") (' p t)) (outn "c") []})(flr {(< 3 _)} [1 2 3 4 5 ])(= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)})
03:15:27 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})(= list (cons 5 (cons 4 (cons 3 (cons 2 (cons 1 (cons 0 nil)))))))(= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})(qs list)
03:16:12 <oklopol> :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1))) (-> $length (+ 1 (length t)))})})(= list [6 5 4 3 2 1 0])(= qs {(-> (: h t) (+ (qs (flr {(< _ h)} t)) (+ [h] (qs (flr {(>= _ h)} t))))) []})(qs list)
03:16:25 <oklopol> same thing, but primitive list
03:16:58 <oklopol> interface-based stuff is quite impressive when your own language supports it <3
03:17:52 <oklopol> i'll leave the bot on, so if you wanna play, do so
03:21:09 <oklopol> adu: if you wanna read a larger example, http://www.vjn.fi/pb/p551616525.txt
03:31:21 <Sgeo> I guess I can't learn oklotalk now
03:56:51 -!- adu has quit ("Bye").
05:03:03 -!- captluo has joined.
05:10:11 -!- Sgeo has quit (Remote closed the connection).
05:11:05 -!- oktabot has quit (Read error: 104 (Connection reset by peer)).
05:11:20 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
05:42:11 -!- Visitor-3CB98 has joined.
05:46:51 -!- oklopol has joined.
05:50:51 -!- GreaseMonkey has joined.
06:27:39 -!- RodgerTheGreat has quit.
06:55:14 -!- oklopol has quit (Connection timed out).
07:19:06 -!- calamari has quit ("Leaving").
07:35:09 -!- oklopol has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:36:44 -!- iebnn has joined.
08:36:48 -!- captluo has quit (Read error: 104 (Connection reset by peer)).
08:48:26 -!- Iskr has joined.
09:40:05 -!- oklofok has joined.
09:44:24 -!- oklopol has quit (Read error: 113 (No route to host)).
09:52:34 -!- GreaseMonkey has quit ("zzzzz").
10:16:19 -!- ehird has joined.
11:55:28 -!- Visitor-3CB98 has changed nick to Slereah.
12:10:04 -!- Corun has joined.
12:31:42 <ehird> stupidfilter alpha is out
12:43:40 -!- Corun has quit ("This computer has gone to sleep").
13:42:49 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
13:43:07 -!- Judofyr has joined.
13:59:45 -!- Sgeo has joined.
13:59:47 -!- jix has joined.
14:07:05 <Slereah> I think I found a way to resolve my inner-recursion woes.
14:08:22 <Slereah> I will use the awesome U~ combinator, that I just made up.
14:08:33 <Slereah> It is called "Seor Turingos Combinator"
14:10:07 <Slereah> Of the form ^x^y [A function of y that converts to i that performs possible outputs] ((([Some conditional, function of y](xx))i)[Some function of y])
14:16:56 -!- Sgeo has quit ("Ex-Chat").
14:28:54 <Slereah> Of the form ^x^y [A function of y that converts to i that performs possible outputs] ((([Some conditional, function of y](xx))i)[Some function of y])
14:51:28 -!- timotiis has joined.
15:25:32 -!- timotiis has quit (Read error: 110 (Connection timed out)).
15:30:52 -!- timotiis has joined.
15:49:39 <ehird> would building an Analytical Engine practical?
16:06:19 -!- timotiis has quit (Read error: 110 (Connection timed out)).
16:06:47 -!- UnrelatedToQaz has joined.
16:33:07 -!- UnrelatedToQaz has quit ("ChatZilla 0.9.81 [Firefox 3.0b5/2008032620]").
16:41:18 -!- RodgerTheGreat has joined.
16:51:26 -!- jix has quit ("CommandQ").
16:51:53 -!- jix has joined.
17:13:31 -!- timotiis has joined.
17:24:52 -!- Sgeo[College] has joined.
17:44:21 -!- olsner has joined.
17:45:48 -!- timotiis has quit (Read error: 110 (Connection timed out)).
18:05:10 <ehird> EVERYONE IS DEAAAD
18:08:22 <olsner> ehird: no, it is you who is dead
18:20:02 <iebnn> My brain is fucked
18:20:15 -!- timotiis has joined.
18:21:38 <ehird> iebnn: hello, are you new here?
18:21:49 <ehird> don't recognize your nick
18:23:23 <ehird> now, escape while you can
18:24:07 -!- Sgeo[College] has quit ("http://www.mibbit.com ajax IRC Client").
18:26:58 -!- Sgeo[College] has joined.
18:28:47 -!- sekhmet has quit ("it's a reboot!1!").
18:32:08 -!- Sgeo[College] has quit ("http://www.mibbit.com ajax IRC Client").
18:44:21 -!- captluo has joined.
18:45:13 -!- iebnn has quit (Read error: 104 (Connection reset by peer)).
18:46:52 -!- timotiis has quit (Read error: 110 (Connection timed out)).
18:49:23 -!- sekhmet has joined.
18:50:12 -!- timotiis has joined.
18:51:39 -!- jix has quit (Nick collision from services.).
18:51:49 -!- jix has joined.
19:03:45 -!- captluo has quit.
20:31:22 -!- Iskr has quit ("Leaving").
20:37:32 -!- ais523 has joined.
20:41:25 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
20:41:56 -!- Judofyr has joined.
20:55:25 -!- Tritonio__ has quit (Remote closed the connection).
20:59:12 * ais523 is trying to write an IRC client in INTERCAL
20:59:20 <ais523> but I think there's a bug in CLC-INTERCAL's network connection code
20:59:47 <ais523> I can send information to the IRC server, but I can't get any information back
21:00:08 <ais523> neither on freenode, or the local not-externally-accessible IRC server I use for testing
21:01:02 -!- Tritonio_ has joined.
21:01:43 <ais523> the strange thing is that the same code can get information back fine from an HTTP server
21:02:16 <ehird> ais523: IRC's special chars, maybe?
21:02:31 <ais523> actually, it may be a problem with my code
21:03:03 <ais523> I just aimed the HTTP GET code at irc.freenode.net:6667, and got typical error messages back
21:04:08 <ais523> incidentally, how's this for a filename: ickirc-c.rstclci.in
21:07:42 <ehird> ais523: rstclci ... what is THAT
21:08:01 <ais523> ehird: CLC-INTERCAL source with syscall, INTERNET, and threads extensions enabled
21:08:23 <ais523> (n.b. INTERNET != Internet; it's the name for CLC-INTERCAL's INTERCAL NETworking extension)
21:09:04 <ehird> Speaking of IRC, I am currently writing a semantic IRC framework.
21:09:21 <ehird> Which basically boils down to it understanding the semantics of the protocol innately, instead of dumbly parsing & deparsing text.
21:09:33 <ehird> e.g. 'join' messages can have callbacks, because it tracks queues of requests
21:10:07 <ais523> ah, because most of the numerics are responses to something or other?
21:10:20 <ais523> and likewise ERROR is a response to QUIT as well as being a standalone message
21:10:41 <ehird> Also, each type of message has its own class
21:10:47 <ehird> PRIVMSG, PING, etc.
21:11:07 <ehird> And a PRIVMSG #esoteric :foo has 'channel' and 'text' attributes, instead of relying on dumb indexing
21:11:13 <ehird> Indeed it will even do WHOISes
21:11:18 <ehird> and give you a simple object back
21:11:23 <ehird> whereas the actual whois output is obscene
21:12:09 <ehird> Also, instead of 'bot = server connection'
21:12:18 <ehird> or even 'bot = one channel' like some things assume
21:12:23 <ehird> it knows that a bot is spread across multiple networks
21:12:27 <ehird> and a network has servers
21:13:04 <ais523> the design of IRC is quite clever. Normally, you don't need to know that a network has servers unless you're a severl operator
21:13:14 <ais523> because all the messages handle them more or less transparently
21:13:21 <ehird> ais523: I mean load-balanced servers
21:13:25 <ehird> like kubirck.freenode.net etc
21:13:35 <ehird> ais523: All IRC clients have a concept of 'Networks' if you look in them
21:13:41 <ehird> 'cause they're a useful concept :-)
21:13:46 <ais523> ehird: yes, definitely
21:13:52 <ais523> knowing that a network has servers is less important
21:14:08 <ais523> the main difference it makes to the end-user is whether you get an idle-time notification in a WHOIS
21:14:54 <ehird> ais523: $CLIENT will also have servers in networks if you look closely
21:15:07 <ais523> incidentally, ais523_ is still online, despite not responding to pings
21:15:25 <ais523> it goes into an infinite loop rather than reading back from the IRC server
21:15:42 <ais523> but if I give it an alphanumeric buffer that's too small, it errors, so /something/ strange is going on
21:17:25 -!- olsner has quit ("Leaving").
21:17:31 <ehird> i have always disliked the look of /italics/
21:17:41 <ehird> and i never use underlines, so i use _italics_
21:18:29 <ais523> in a man page, the .I directive writes an underline
21:18:49 <ais523> and so presumably in nroff too, when formatting for display on a terminal
21:19:02 <ehird> ais523: underlines are totally useless though
21:19:12 <ehird> italics & bold cover everything i need to express
21:19:17 <ais523> ehird: what about links?
21:19:35 <ehird> ais523: i don't manually underline links
21:19:42 <ais523> the reason that underlines fell out of favour was that nowadays people have become used to recognising them to indicate links
21:19:44 <ehird> in my actual text, i have no need for underlines
21:19:52 <ehird> even if links didn't exist
21:21:18 <ais523> I was always taught to use them to indicate the final outcome of a mathematical problem or other such lengthy situations
21:21:31 <ais523> e.g. if an exam question asked me what 2 + 2 was, I was supposed to answer _4_
21:22:52 <ais523> not sure of the merits of the idea except to save time for examiners, though
21:23:10 <ais523> but I suppose underlines have deteriorated since the days of ALGOL 68 and typewriters
21:23:23 -!- RedDak has joined.
21:26:01 <ehird> I prefer '4, F*CK YEAH'
21:26:07 <ehird> Or some other notable exclamation
21:26:40 <ais523> don't blame me if you get strange comments in your exam feedback, then
21:26:45 -!- RedDak has quit (Client Quit).
21:27:06 -!- RedDak has joined.
21:30:34 <ehird> '2 + 2 = THE ONE THE ONLY 4'
21:30:43 <ehird> '2+ 2 = EFF OH YOU ARE'
21:30:49 <ehird> '2+ 2 = FOOOOOURRRRRRRRRR'
21:32:08 <lament> 2 + 2 = 1 + 3 = 0 + 4 = -1 + 5 = -2 + 6 = ... = -inf + inf = undefined
21:32:35 <ais523> lament: but NaN = 4 in this case
21:32:56 <ais523> the only reason that computers say that NaN is not equal to everything is that they can't be expected to figure out what value it actually has in that case
21:33:37 <ehird> ais523: NaN != NaN in a lot of languages
21:33:42 <ehird> because there are multiple NaNs
21:33:46 <ehird> and NaN always creates a new one
21:33:50 <ehird> JavaScript behaves like this
21:33:55 <ais523> ehird: NaN != NaN in C even if it's the same NaN
21:34:06 <ais523> and there are multiple NaNs, but they compare not equal even if they have the same payload
21:34:14 <ehird> ais523: C has NaN?
21:34:38 <ais523> ehird: you need C99 to be able to express it portably, though, and even then it's optional, I think
21:34:48 <ais523> but the rules for it are defined if it does exist
21:38:42 <ais523> 0./0. is not guaranteed to be NaN, for instance; it might be a SIGFPE instead (or presumably another implementation-defined signal)
21:47:33 <ehird> ais523: I am tempted to implement your s/// correction thing
21:47:42 <ehird> ais523: also star-correction
21:47:48 <ehird> uses leventhsethisen distance or whatever
21:47:51 <ehird> to determine which to change
21:48:03 <ehird> levenshtein actually
21:48:40 <ais523> ehird: I doubt it could handle that, two lines up and in someone else's comment, it would need to know the context of the conversation to even think of looking there
21:48:47 <ais523> and looking there as a matter of course would be stupid
21:49:36 <ehird> ais523: no, it would just scan the N latest messages
21:49:38 <ehird> and choose the one most likely
21:50:01 <ais523> I've been known to correct my own most recent message after tens of minutes, with lots of intervening comments
21:50:19 <ais523> but it's pretty silly, not to mention a security risk, to correct other people's
21:53:02 -!- RedDak has quit (Read error: 110 (Connection timed out)).
21:53:15 -!- Dagide has joined.
21:53:29 <ehird> ais523: only correct as in 'repeat'
21:53:50 <ais523> so that avoids the security risk, at least
21:54:00 <ais523> you could have a bot doing that sort of correction, I suppose
21:54:12 <ais523> what about the times when I typo one of my own corrections and correct that?
21:54:27 <ais523> I often do s/a/b followed by s/$/\// when I realised I missed off the final slash by mistake
21:55:17 <ehird> ais523: it'd retry any stuff it corrects for correction
21:55:19 <ehird> if you see what i mean
21:55:33 <ehird> ais523: incidentally, do you know about #xkcd-signals' ROBOT9000?
21:55:41 <ais523> the solution is not too hard to see, I was just making sure you knew the problem
21:55:59 <ehird> ais523: Basically, if you say something that has already been said before -- ever -- it mutes you.
21:56:07 <ehird> The mutes get progressively greater the more you do it but gradually decrease.
21:56:22 <ehird> So, memes get killed off extremely quickly and only original thought is left.
21:56:26 <ehird> It's an interesting idea.
21:56:33 <ais523> what do you mean by a mute, here? it devoices you, and it's a moderated channel?
21:56:51 <ehird> ais523: I think the main implementation +b's you and then -b's you after the timeout
21:57:03 <ehird> But, same thing in this case
21:57:25 <ehird> ais523: Full scoop: http://blag.xkcd.com/2008/01/14/robot9000-and-xkcd-signal-attacking-noise-in-chat/
21:57:26 <ehird> http://media.peeron.com/tmp/ROBOT9000.html
21:57:26 <ais523> it would be more interesting to see it done with voicing
21:57:28 <ehird> there's the source
21:57:35 <ehird> so you should have no problem figuring it out
21:57:47 <ais523> so that the little V signs, or whatever the client uses, turn on and off as people accidentally repeat
21:57:58 <ais523> but you'd have to be really careful not to say things like 'yes' or 'no'
21:58:09 <ehird> ais523: Well, the idea is that you justify more than 'yes' or 'no'
21:58:14 <ehird> You go 'Yes, the system is configured so that blah.'
21:58:25 <ais523> or maybe just get your client to a ppend a sequence number to the end of everything you said [1]
21:58:27 <ehird> Not perfect for all cases surely. But interesting
21:58:35 <ehird> ais523: as for that idea,
21:58:39 <ehird> it'll just get you banned
21:58:49 <ehird> Just like all bad faith is dealt with in IRC channels
21:59:00 <ais523> hmm... maybe you could do it with whitespace so people didn't notice
21:59:18 <ais523> but it's probably not fair to try to work around that sort of restriction
21:59:25 <ehird> ais523: They would notice when you say the same thing twice
21:59:34 <ais523> depends on what that thing was
21:59:47 <ehird> is a blend of Utu (you may have heard of it) and that
22:00:08 <ehird> If enough people 'hate' you (that's an actual command), it mutes you
22:00:10 <ais523> wow, that code you linked doesn't look like Perl at all, someone's tried to write it like C
22:00:11 <ehird> That's the *basic* idea
22:00:18 <ais523> it's uncomfortable seeing Perl that readable
22:00:19 <ehird> http://savingtheinternetwithhate.com/design.html
22:00:25 <ehird> But basically, doing the above but with an irc bot.
22:00:39 <ehird> ais523: Network::IRC and all that are object-oriented, clean, callback-based frameworks.
22:01:18 <ehird> Most 'modern' perl looks like that
22:02:05 <ais523> that isn't modern perl
22:02:16 <ais523> they call procedures using the & sigil, and that's been deprecated for ages
22:02:36 <ais523> so whoever wrote that is used to old-fashioned Perl
22:08:11 <ais523> ah, they thought of the trailing-whitespace thing
22:08:30 <ehird> lament: put it in #esoteric! as an experiment? ;)
22:08:36 <ehird> xkcd fed two years of logs into it
22:08:43 <ehird> but the logs we have take back to 2004
22:08:44 <ais523> they also remove punctuation and all repeated characters
22:08:48 <ehird> that's gotta be interesting, no?
22:08:55 <ais523> they should probably do Porter stemming as well, just for the fun of it
22:08:57 <ehird> or i can do it if allowed ;)
22:08:58 <lament> we don't have any such issues, though
22:09:04 <ehird> lament: yes, but it would be interesting
22:09:15 <ais523> it might be interesting to set up a bot to report when a user would be banned, rather than actually doing it
22:09:26 <ais523> so we could see what the false-positive rate would be like
22:09:27 <lament> that just leads to more noise though
22:09:34 <ehird> lament: this is just as a temp experiment
22:09:36 <ehird> but yeah, i'll get on it
22:09:41 <lament> ehird: can you just run it on the logs to see which lines would it match?
22:09:43 <ehird> ais523: seen StupidFilter?
22:09:48 <ehird> lament: no, it works there-and-then
22:09:51 <ehird> http://stupidfilter.org
22:09:53 <ais523> maybe report in a second channel, so that people didn't have to look at it if they didn't want to
22:09:56 <ehird> they released an alpha recently
22:09:59 <ehird> but its very slooooww
22:10:00 <ais523> ehird: I hadn't seen it
22:10:06 <lament> ehird: i'm sure it's easy to hack to work in batch mode
22:10:35 <lament> and if all it does is line matching after trimming whitespace, you don't need the bot
22:10:48 <lament> just write a program to check that
22:10:56 <ais523> lament: you don't even need to write a program
22:11:03 <ais523> some combination of sort and uniq would work
22:11:11 <ais523> but it also filters out nicks, smilies, punctuation, etc
22:11:34 <lament> throw out everything except alphabetic chars
22:11:40 <ais523> also case and control characters
22:11:50 <lament> they can't contribute to false positives much
22:11:51 <ais523> lament: no, do Porter stemming first
22:12:07 <ais523> so that you can't just add -ing on the end of a word to create a different line
22:12:14 -!- ehird has changed nick to ROBOT9000.
22:12:17 -!- ROBOT9000 has changed nick to ROBOT9001.
22:12:17 <ais523> Robot9000 doesn't do that, by the way
22:12:39 <lament> anyway, it seems in half an hour you could get some good estimates
22:12:50 -!- ROBOT9001 has changed nick to ehird.
22:13:05 <ehird> # if the channel is quiet for too long (longer than fortune_time, in seconds),
22:13:05 <ehird> # print the output of the fortune_command. Remove to disable this feature.
22:13:22 <ehird> ais523: it IS based on voice
22:13:32 <ehird> so that unfortunately means it needs ops
22:13:53 <ais523> it's based on both voice and ban as far as I can tell
22:14:08 <ais523> at least, the code is capable of doing both of those
22:14:41 <ais523> anyway, I was going to suggest running it as a simulation rather than actually banning
22:15:01 <ehird> ais523: yeah, i will
22:15:03 <ehird> just setting it up first
22:15:04 <ehird> my $dbh = DBI->connect( "DBI:mysql:database=$config->{db_name}",
22:15:04 <ehird> $config->{db_user}, $config->{db_pass} )
22:15:08 <ehird> what should that be for sqlite?
22:15:17 <lament> i think simulating it on the logs would be more informative
22:15:23 <lament> (by finding matching lines in the logs)
22:15:42 <lament> you'd find out everything the bot would have done in the past ~3 years
22:16:11 <ais523> oh, it also bans and devoices people who change nick too often
22:16:17 <ais523> and blocks newly-arriving users for a minute
22:19:58 <ehird> it comes with nothing to import logs
22:20:57 <ais523> ehird: just run through each line calling the callback for someone saying something
22:21:40 <ehird> ais523: Non-trivial. Network::IRC isn't simple.
22:21:52 <ehird> & the logs are not in raw format
22:22:29 <ais523> ehird: just call irc_on_public
22:22:34 <ais523> rather than messing with Network::IRC at all
22:22:49 <ehird> my ( $self, $event ) = @_;
22:22:49 <ehird> my ( $nick, $userhost ) = ( $event->nick, $event->userhost );
22:22:49 <ehird> my ($msg) = ( $event->args );
22:22:58 <ehird> from irc_on_public
22:23:04 <ais523> that's not too complicated a call to manage
22:23:09 <ais523> it would look something like this:
22:23:15 <ehird> ais523: Add that to parsing the logs...
22:23:24 <ehird> However, I will download all the logs and munge them together
22:23:42 <ehird> ais523: Your idea sucks. It will retroactively punish
22:23:50 <ehird> So, e.g., most people in here will have mute times off the csale
22:23:54 <ehird> i can fix that myself
22:24:00 <ehird> time to brush up on my wget-fu
22:24:14 <ais523> irc_on_public($self,(nick => "somenick", userhost => "somefakeuserhost", args => $msg))
22:24:43 <ehird> yeah, and where to get the self from?
22:25:03 <ehird> ais523: Also, it interacts with irc: it will try to voice & kick etc
22:25:07 <ais523> ehird: it only cares about it when kicking
22:25:21 <ais523> so just comment all the lines that use it and pass in undef or something
22:25:33 <ais523> that'll do for filling the database, then you can comment them back in again
22:25:46 <ais523> or if you're feeling clever, make it skip all those lines if $self is undef
22:26:30 <ehird> i'll make it beep when it was going to kick someone
22:26:34 <ehird> interactive lightshow :D
22:27:11 <ehird> actually, my semantic irc framework would rock for this
22:27:14 <ehird> just give it a dummy irc server
22:27:16 <ehird> filled with the logs
22:27:49 <ais523> I have to go, now, anyway. Bye!
22:27:51 -!- ais523 has quit ("(1) DO COME FROM ".2~.2"~#1 WHILE :1 <- "'?.1$.2'~'"':1/.1$.2'~#0"$#65535'"$"'"'&.1$.2'~'#0$#65535'"$#0'~#32767$#1"").
22:28:23 -!- Dagide has quit (Remote closed the connection).
22:29:21 <ehird> lament: bespin.org is FEELING MY PAIN
22:29:29 <ehird> KILL KILL KILL, YOUR SERVER MUST DIE
22:31:05 <ehird> It's on to 2006 already.
22:35:52 <AnMaster> Deewiant, the HRTI test of mycology adds a total of over 0.030 seconds
22:36:14 <AnMaster> Deewiant, so far that is the single slowest fingerprint to test
22:39:15 <ehird> all logs downloaded
22:43:25 -!- jix has quit ("CommandQ").
22:43:43 <ehird> lament: I have 426682 lines of logs processed ready
22:44:34 <ehird> if (@ARGV) { # we're only loading an existing log file, not actually running
22:44:34 <ehird> print "Loading log files...\n";
22:44:37 <ehird> it already can do it
22:49:39 <ehird> lament: So since ROBOT9000 already supports loading logfiles, I could just quickly load it up now and then put it in here as a quick experiment.
22:52:50 <lament> it would take us weeks to reach any interesting conclusions; we don't talk much
22:53:16 <lament> so simulating its actions in the logs is far more informative
22:53:45 <lament> as long as it doesn't actually hurt anybody :)
22:54:06 <ehird> lament: well, that's the problem -- it won't run without ops
22:54:15 <lament> (you just said wheeee, okay, hm and lulz in the past 15 minutes - you would be very muted now)
22:54:27 <ehird> not just any kind of muted, but VERY muted
22:54:35 <ehird> lament: i don't think i can fix it, the whole architechture is based on it
22:55:17 <lament> why don't you just search for duplicates in the log files? :)
22:55:41 <lament> i bet most of the duplicates are short things like "okay"
22:55:42 <ehird> lament: because that's nothing like what robot9000 does
22:56:00 <lament> can't you just steal its text-processing algorithm
22:56:08 <lament> presumably it's a separate procedure
22:56:11 <lament> you don't need the rest of the bot
22:56:28 <ehird> lament: no, its not a seperate procedure
22:56:36 <ehird> i'm going to load the logs into it
22:56:38 <ehird> and see what happens
22:56:42 <lament> wow, this bot sounds more and more like a perl program :)
22:56:49 <ehird> lament: well, it is perl
22:58:46 <ehird> zsh: bus error perl ROBOT9000.pl ROBOT9000.yml logs/combined.txt
23:00:32 <lament> and you want that thing to ban people? :)
23:01:11 <ehird> lament: hehe, well it is processing them now
23:01:14 <lament> what could possibly go wrong!
23:01:27 <ehird> this is a lot of stuff
23:01:47 <ehird> I'll just let it do its thing..
23:03:05 <ehird> lament: it keeps recording empty lines. heh!
23:03:15 <ehird> Still, if xkcd are using it, it must work pretty well
23:06:31 <ehird> lament: Sheesh, people talk about a lot of crap in #esoteric.
23:06:56 <lament> it's pretty good now compared to what it used to be at one point
23:07:22 <ehird> the value is an anti-alias factor setting it to 1 disables the anti-aliasing feature this makes the output look bad but setting it too high makes the trace take a lot more time to complete
23:07:25 <ehird> that just scrolled past
23:07:28 <lament> (we actually talk about programming stuff once in a while as opposed to just talking about manga and social incompetence)
23:07:32 <ehird> (Incidentally, I would have just been muted, ironically)
23:12:06 <ehird> lament: sheehs, this is such a waste of cpu time
23:22:28 -!- oerjan has joined.
23:22:36 <ehird> lament: Sti-i-i-hillll going
23:25:19 -!- oerjan has quit (Client Quit).
23:27:22 -!- oerjan has joined.
23:42:01 <ehird> lament: still going
23:49:40 <lament> i wait with bated breath
23:51:36 * oerjan is surprised to learn that "bated" is the correct spelling
23:55:40 <ehird> time for new and improved garbage
23:55:40 <ehird> oh and that is the previous newline