00:04:02 :: 2 00:04:02 2 00:04:04 :: / 00:04:04 / 00:04:07 :: (= / +) 00:04:07 + 00:04:10 :: (/ 5 5) 00:04:10 10 00:04:15 hah 00:04:23 D: 00:04:24 wtf 00:04:43 oh 00:04:44 :d 00:09:19 let's fix that 00:09:24 :: (= / $/) 00:09:25 / 00:09:30 :: (/ 5 5) 00:09:31 1 00:10:20 oklofok: no built-in-function type? XD 00:10:31 hmm? 00:10:51 oklofok: specialcasing atoms, thingy 00:10:58 oklofok: shouldn't / be a built-in function? 00:11:00 that sends the atom off 00:11:03 no, it's an atom 00:11:14 errt 00:11:26 the dispatch is just plain oklotalk logic 00:11:39 as i said, it's not (func arg arg) 00:11:42 it's (expr expr expr) 00:11:52 the expressions are asked to perform the operation, one by one 00:12:00 the one who wants to, does it 00:12:12 and if no one wants to do it, the first one is asked to 00:12:31 and yes, "wanting" is the official term 00:19:19 oklofok: haha 00:19:49 :: ($/ $/ $/) 00:19:49 / 00:20:02 oklofok: so, it asks $/ to $/ with $/ 00:20:05 then asks $/ to $/ with $/ 00:20:07 yeah! 00:20:08 since neither wants to do it 00:20:12 it asks $/ to $/ with $/ 00:20:18 and it says 'oh fuck it' and returns itself 00:20:34 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 usually, that's just what you want 00:21:00 but the feature is useless atm 00:21:20 it won't be once i add... well, querying what wants to evaluate 00:21:24 which is trivial really 00:21:34 but has to be done in order to get done, anyway 00:21:50 oklofok: so {} is just a ' 00:21:56 doer' 00:22:09 {} is a doer, yeah 00:22:10 and doers can want to do some things (isomorphic to function calls) 00:22:17 and not do others (unique to oklotalk) 00:22:18 yeah. 00:22:25 well 00:22:29 and that's why you can use {} as a function 00:22:34 things don't want to do everything 00:22:41 oklofok: 00:22:43 i mean, 1 doesn't want to add a complex to itself 00:22:44 'and not do others' 00:22:54 which is why something like __radd__ can be made 00:22:56 hmm 00:23:08 actually i'm not sure i understood 00:23:58 oklofok: {...} creates a 'thing' 00:24:02 things have a few properties: 00:24:24 - 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 - everything that they don't explicitly want to do, they don't, and cascade 00:24:46 yep. 00:24:52 the 'actions' inside 00:24:53 are closures 00:25:02 so {(-> [a b] {...})} 00:25:09 the inner 'thing' can access the stuff given 00:25:14 and the outer 'thing' acts like a function 00:25:41 something like that 00:25:46 well 00:26:03 it's really about whether a thing will evaluate any expression given a certain argument 00:26:27 so if a function starts with an action, it will want all args 00:29:32 like {outn "an function was entered"; ptrn -> smth} will always want 00:29:35 everything 00:30:10 Somehow, it amuses me greatly that my math teacher from last year has offered me a ride to the Shadowmoor prerelease. 00:30:24 what's that 00:30:36 Shadowmoor is the next Magic: The Gathering set. 00:30:40 oklofok: oh you can do that?! 00:30:49 ehird: what? 00:30:59 :: (= myId {outn "boo"; (-> x x)}) 00:31:01 <<<20586168>>> 00:31:01 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:04 :: (myId 2) 00:31:06 2 00:31:08 hmm 00:31:10 :| 00:31:10 almost. 00:31:25 1. no output in oklotalk--, it goes in my terminal 00:31:38 2. no ; in oklotalk--, just space to separate expressions 00:31:46 3. () for application 00:32:01 {outn "boo"; (-> x x)} works 00:32:03 ... 00:32:09 {(outn "boo") (-> x x)} works 00:32:18 but you can't show it, because no side-effects are visible 00:32:36 well... 00:33:22 :: (= x {(-> n {(-> [$set n] n) (-> $get n)})}) 00:33:23 <<<20547584>>> 00:33:32 :: (= test (x 4)) 00:33:34 <<<20643512>>> 00:33:36 :: (get test) 00:33:38 4 00:33:42 oklofok: hah 00:33:44 :: (set test 7) 00:33:47 7 00:33:48 i'm going to make a linked list 00:33:50 :: (get test) 00:33:52 7 00:34:01 so, we have a pointer here 00:34:03 now... 00:34:06 side-effects 00:34:27 oklofok: is just (-> [$pb] ...) ok? 00:34:30 :: ({(set test 8) (-> n (* n 3))} 5) 00:34:32 15 00:34:36 test 00:34:40 :: test 00:34:42 <<<20643512>>> 00:34:49 :| 00:34:52 oh 00:34:56 :: (get test) 00:34:58 8 00:35:10 so, yes, you can do it 00:35:33 ehird: no it's not 00:35:36 i mean 00:35:40 it will not match 00:35:45 you wanna get like tail? 00:35:51 $pu as pattern 00:35:54 pattern-match unary 00:37:29 oklofok: ok, define $pb message to me exactly 00:37:34 what is sent [$pb ???] 00:37:36 :: (= ptr {(-> n {(-> [$set n] n) (-> $get n)})}) 00:37:37 and what should i return 00:37:39 <<<20667808>>> 00:37:43 well 00:37:52 ok wait 00:37:55 in your ptr thing 00:38:00 when something is pattern matched on an application of the form (x y z) 00:38:03 does the 'n' override the upper scopes 'n'? 00:38:07 actually 00:38:10 just continue answering 00:38:16 the message [$pb x] is sent to the object. 00:38:28 and if it returns a list with 2 elems, those are put into y and z 00:38:33 hmm 00:38:41 hmm 00:38:55 ehird: what do you mean? 00:39:01 :: (= n 1) 00:39:03 1 00:39:11 :: (= ptest (ptr 8)) 00:39:13 <<<20660096>>> 00:39:17 :: (get ptest) 00:39:19 8 00:39:25 :: (set ptest 10) 00:39:27 10 00:39:32 :: (get ptest) 00:39:34 10 00:39:36 :: n 00:39:39 1 00:39:47 does that answer you? 00:40:24 i'm fairly sure i've done all scoping *well*, at least it usually seems to work whatever i do 00:40:32 :: (= cons {(-> [h t] {(-> [$pb cons] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t)})}) 00:40:34 <<<20680136>>> 00:40:40 :: (= test (cons 1 2)) 00:40:43 <<<20689544>>> 00:40:46 :: (car test) 00:40:47 1 00:40:49 :: (cdr test) 00:40:51 2 00:40:55 :: (setcar test 3) 00:40:57 3 00:40:58 :: (car test) 00:41:00 3 00:41:04 :d 00:41:07 :D 00:41:09 i am awesome 00:41:09 :D 00:41:19 do $pb : 00:41:22 oklofok: oklotalk is cool. could use some nicer syntax though, yeah ;) 00:41:27 because that's the standard 00:41:29 then do indexing 00:41:32 oklofok: okay 00:41:34 i won't do indexing 00:41:36 it's just a cons cell 00:41:37 not a list 00:41:38 and we'll try quicksort :D 00:41:43 you can treat it like a list though 00:41:44 but i want to see ! 00:41:45 oh alright 00:41:46 what is indexing 00:41:51 hmm 00:41:55 [$! i] 00:42:05 oklofok: can you define setters? 00:42:08 (= FOO BAR) 00:42:08 in lisp 00:42:11 you can override FOO 00:42:13 based on its car 00:42:13 like 00:42:15 not yet. 00:42:15 (= (car x) y) 00:42:20 hmm 00:42:21 you can define a setter for (car x) 00:42:26 ah 00:42:30 presumably, it would be like $pb 00:42:33 it would send off 00:42:36 that isn't done yet, = only does vars 00:42:37 [$= car] 00:42:42 but that's just because i'm lazy 00:42:46 it will do that, yeah 00:42:48 but i dunno what would be returned 00:42:50 :| 00:42:52 ah wait 00:42:55 [$= car val] 00:42:56 of course 00:43:12 (= (X Y) Z) -> (X [$= Y Z]) 00:43:30 hmm... 00:43:39 oklofok: what is the syntax I use for indexing? 00:43:41 well 00:43:41 like not defining 00:43:42 but using 00:43:53 (! list idx) 00:44:01 :: (! [1 2 3] 0) 00:44:03 actually... 00:44:04 1 00:44:21 it might be that the quicksort doesn't work if the list isn't primitive... 00:44:27 depends on how i've done filter... 00:44:34 oklofok: you can implement filter in oklotalk 00:44:39 sure 00:44:44 and would be much cooler too 00:44:47 actually... 00:44:47 :: (= cons {(-> [h t] {(-> [$pb :] [h t]) (-> $car h) (-> $cdr t) (-> [$setcar h] h) (-> [$setcdr t] t) (-> [$! 0] h) (-> [$! n] (! t (- n 1)))})}) 00:44:50 <<<20634360>>> 00:44:52 trivial 00:44:54 oklofok: ok, try quicksort 00:45:03 well 00:45:08 need to do filter first. 00:45:57 hmph 00:45:59 actually 00:46:06 oklofok: just try it 00:46:10 oh wait 00:46:11 i need a nil 00:46:13 that's not hard 00:46:19 oklofok: how do i trigger an error? 00:46:31 ...error? 00:46:33 wuzzat 00:46:35 return $f 00:46:35 oklofok: like this: 00:46:37 :: [ 00:46:39 [] 00:46:41 err 00:46:42 :: ( 00:46:46 :D 00:46:46 An error: Empty application. 00:46:48 see 00:46:51 oklofok: 'An error:' 00:46:59 you can't. 00:47:02 sry 00:47:04 you should add that, sometime 00:47:16 well, i could, in oklotalk-- 00:47:49 but it's not very oklotalky, unless you've stored the continuation for the return somewhere 00:47:54 well... 00:48:02 oklofok: it should be oklotalky 00:48:03 otherwise 00:48:04 you get errors 00:48:06 i guess you can just implement that without explicit continuations 00:48:06 propogating 00:48:08 since nothing ever fails 00:48:11 so it's really hard to debug 00:48:13 also, code doesn't get shorter 00:48:19 since you have to manually check for errors 00:48:27 and yeah, you can just do it with exceptions 00:48:35 which are a special, downwards-only, one-shot form of continuations 00:48:51 well i could do that just with a simple *python exception*, in like a few lines 00:49:02 :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f)}) 00:49:05 <<<20666208>>> 00:49:16 but perhaps later, right now i need to add a thing to get filter to work 00:49:19 because.. 00:49:38 :: (= nil {(-> [$pb :] $f) (-> $car $f) (-> $cdr $f) (-> [$setcar h] $f) (-> [$setcdr t] $f) (-> [$! n] $f) (-> $length 0)}) 00:49:43 <<<20716400>>> 00:49:50 you can't dispatch on anything except what the object matches on 00:50:03 :: (= 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:05 <<<20716360>>> 00:50:11 i'll add the tst function 00:50:13 :: (length (cons 1 (cons 2 nil))) 00:50:15 2 00:50:26 ...length? 00:50:27 oklofok: i think i might be the best oklotalk coder next to you 00:50:28 ;) 00:50:31 oh 00:50:31 and yeah, length 00:50:33 hehe :D 00:50:35 prolly. 00:50:39 :: (2 + 2) 00:50:41 4 00:50:44 hahahahah 00:50:45 :D 00:50:46 :D 00:50:47 xD 00:50:49 oklotalk is FLEXIBLE 00:50:54 unintentionally 00:50:54 :: (2 2 +) 00:50:58 f 00:51:00 awwww 00:51:02 THAT SUCKS 00:51:06 well 00:51:10 oklofok: make it try ALL PERMUTATIONS 00:51:11 :DDD 00:51:12 it will work in actual oklotalk :D 00:51:17 that's an implementation defect. 00:51:19 haha 00:51:21 3 4 + 00:51:23 will try 00:51:24 3 4 + 00:51:26 3 + 4 00:51:29 4 3 + 00:51:31 4 + 3 00:51:33 + 3 4 00:51:34 + 4 3 00:51:34 etc 00:51:36 until one works 00:51:38 :DDDDDD 00:52:05 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 you can do for instance (* n) for matching any number of n's in a list 00:52:26 with an uplevel match 00:52:28 now 00:52:34 oklofok: still 00:52:36 try all permutations 00:52:37 it's ROBUST 00:52:38 :DDD 00:52:44 you can have patterns in a certain kind of list 00:52:46 heh 00:52:48 why not :P 00:52:52 it's just there's only 6 00:53:01 well... why not, why not xD 00:53:05 but, my point is 00:53:17 you know when you have lots of types 00:53:32 if you have a program with type checks and such 00:53:48 so you could basically have the program just guess what arg is what based on types 00:54:05 oklofok: however, i still think you need a propogating error message mechanism 00:54:06 i mean 00:54:08 (prm [(int x) (str y) (lst z)]) 00:54:09 oklotalk's crazy ideas are fun 00:54:10 :D 00:54:13 but if you are actually gonna write something 00:54:16 :p 00:54:18 that will match them in any order 00:54:26 c has tons of fun because it does not have exceptions 00:54:31 there's a global variable errno 00:54:35 and everything sets it if it dies 00:54:38 propogating error messages? 00:54:40 so you have to check errno after most calls 00:54:42 totally hilarious 00:54:45 uhh, yeah, that's ugly. 00:54:48 well 00:54:49 oklofok: if you don't handle them, they bubble up the call stack 00:54:53 python's do those 00:55:12 oklotalk should just allow you to step out of the evaluation, without actually even using continuations or anything 00:55:20 i mean 00:55:34 you can just move in the parse tree up to a try or something 00:55:41 i've written some fun thingies with this 00:56:01 heh, oklotalk has so much shit... 00:56:13 ehird: well yeah, exceptions 00:56:17 i know the concept 00:57:00 that "stepping a level up" can be used for something like define-syntax 00:57:32 hmm 00:57:34 what was i gonna do.. 00:59:20 -!- ehird has quit ("This computer has gone to sleep"). 01:00:11 :: reload 01:00:14 -!- otobot has quit (Remote closed the connection). 01:00:20 :| 01:01:45 -!- otobot has joined. 01:03:44 " Usage: NOTICE , sends a notice. Notices are a type of message that should be auto reacted to" isn't that exactly wrong? 01:05:03 :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst {(f h)})) t) (+ [h] (' f t))]) (-> [f (: h t)] (+ [h] (' f t)))}) 01:05:05 <<<19347336>>> 01:05:18 :: (flr {(< _ 3)} [1 2 3 4 5]) 01:05:20 [1 2 3 4 5] 01:05:25 darn 01:05:39 ({(< _ 3)} 7) 01:05:46 :: ({(< _ 3)} 7) 01:05:48 f 01:06:40 :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t) (+ [h] (' f t))]) (-> [f (: h t)] (+ [h] (' f t)))}) 01:06:42 01:06:43 :: (flr {(< _ 3)} [1 2 3 4 5]) 01:06:46 [1 2 3 4 5] 01:07:58 :: ({(> _ 3)} 7) 01:08:04 t 01:08:20 oh 01:08:46 :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))}) 01:08:51 :: (flr {(< _ 3)} [1 2 3 4 5]) 01:08:58 01:09:00 An error: Var instance has no attribute 'call' 01:09:09 :) 01:09:35 ah 01:09:52 :: reload 01:09:54 reload 01:09:59 :: (= flr {(-> [f []] []) (-> [f (: (@ h (tst f)) t)] (+ [h] (' f t))) (-> [f (: h t)] (+ [h] (' f t)))}) 01:10:01 <<<19507280>>> 01:10:05 :: (flr {(< _ 3)} [1 2 3 4 5]) 01:10:07 An error: Var instance has no attribute 'call' 01:10:13 wtf. 01:11:20