00:08:40 foo<-{n->{i->n++i}} 00:08:55 foo<-\n.\i.n++i 00:12:18 Main :: 0 00:12:18 = RNode 4 1 0 00:12:18 = RNode 4 2 0 00:12:18 RNode n t p = RNode 0 n t p 00:12:18 RNode m m t p :: p 00:12:19 RNode n m t p :: #node n t -> RNode n+1 m t p 00:12:23 eight! 00:12:37 ...close in complexity to the hypercube 8| 00:12:58 what a verbose lang, i need those shorthands... 00:15:23 What's ASCII 96? `? 00:15:30 Doesn't appear on my chart. 00:16:32 oklopol! how would you like to help devise a language even more concise than oklotalk 00:16:46 with only one goal: tiny code 00:16:53 well, tiny code that can be written fast :-) 00:18:23 starting on what basis? 00:18:58 oklopol: hm, insanity 00:19:06 or: functions, mainly, i guess 00:19:10 functions and mutations 00:19:33 typing makes things concise because it allows for massive overloading. 00:19:54 ok then 00:19:56 type inference? 00:20:02 or dynamic typing 00:20:19 hmm 00:20:50 well, definately not explicit typing :) 00:21:11 ofc 00:21:16 type inference could be fun 00:21:16 yep 00:21:25 you could build up a huge knowledge base of info about functions 00:21:35 it could know more about how a function behaves than you do :P 00:21:41 but then type inference can get complex 00:21:46 also, less possibility for operator abuse 00:21:59 indeed, never tried implementing it though 00:22:09 so... dynamic typing? 00:22:17 prolly 00:22:21 ok 00:22:30 let's get some sort of grammar 00:22:37 we want prefix, binary, and postfix operators 00:22:42 also N-ary binaries 00:22:44 that is 00:22:46 hehe 00:22:48 ARG op ARG ARG ... 00:22:58 i don't think ARG ARG ... op ARG ARG ..., though 00:23:01 that would be confusing 00:23:22 perhaps. 00:23:33 what usage would that have 00:23:40 asdf i remember i came up with a language some time ago, but i forgot what it was.... 00:23:46 how do you parse arg op arg arg? 00:25:21 dunno 00:25:23 K does it 00:26:50 oklopol: instead of thinking about that 00:27:01 oklopol: let's just say: prefix, postfix, binary 00:27:12 arg op arg arg would be arg op (arg arg), i.e. second arg a list 00:27:16 so 00:27:23 what about the 'function' operator 00:27:35 i think: [] 00:28:05 [_+1] or [x;x+1] 00:28:08 oklopol: good so far? 00:28:36 seems to work. 00:28:50 but that's a given since there's no sidestep from K :P 00:28:57 K does it? huh 00:29:02 i don't think so... 00:29:05 ok, now let's define two functions over lists 00:29:09 specifically, map and fold 00:29:13 \ is fold 00:29:21 / is map 00:29:24 Postfix operators 00:29:37 func\ is a function f 00:29:42 f called with a list does fold over that list with func 00:29:45 same for / but with map 00:29:51 +\1 2 3 -> 6 00:30:03 +/(1 2) (3) -> (3) (3) 00:30:15 that works as long as you can't change the meaning of \ during the program 00:30:25 yes, and? 00:30:26 well, as long as it always is a postfix oper. 00:30:31 it is 00:30:36 x/ and x\ 00:30:42 +\1 2 3 is really: 00:30:44 well, i mean if you want to make your own postfixors. 00:30:46 (+\) 1 2 3 00:31:12 if you can't make them, then the separation into postfix operators is useless and the terminology of K can be used 00:31:19 verbs & proverbs 00:31:21 [_+2]/1 2 3 -> 3 4 5 00:31:22 oklopol: you can 00:31:28 oklopol: you can define all kinds of ops 00:31:40 [x;x+2]/1 2 3 -> 3 4 5 00:31:47 yes, well in that case, those need to be type checked at compile time. 00:31:59 which somewhat rules out dynamic typing 00:31:59 nah 00:32:01 dynamic typing 00:32:02 no? 00:32:16 /, \ use their arg as a func 00:32:25 if it's a number, the interpreter balks out 00:32:30 it will change parsing if you change a postfix operator into a prefix one. 00:32:52 how does k handle this 00:33:11 i don't think proverbs are first class 00:33:19 although i don't *know* 00:33:50 ok, well then parsing can be changed at runtime 00:33:50 :D 00:33:53 *adverbs 00:33:55 not proverbs 00:34:02 compiling will probably be possible with some tricks 00:34:21 like no matter what an op is compiled as prefix,postfix,infix depending on how its used 00:34:26 when multiple choices, both are tried 00:34:31 and it is resolved at runtime 00:35:01 oklopol: should we have pattern matching? 00:35:05 and if so, what syntax 00:35:38 hmmm 00:35:49 uhhh K-tree <3 00:36:08 i *have* to get my hands on a K interp or make one myself... 00:36:10 echo 'define k-tree' | ehirdtalk 00:36:19 heh 00:36:37 upi can get a free K interpreter from Kx 00:36:39 as in beer 00:36:51 what? 00:36:59 *-up, or what's upi? 00:37:08 you 00:37:16 xD 00:37:23 oh, heh 00:38:28 hm 00:38:31 kx.com is confusing 00:38:32 pattern matching can make things more concise, definitely, the problem is the kind of iterative programming K does is much more comcise 00:38:32 no info abotu K 00:38:33 *concise 00:39:17 oh well 00:39:18 http://www.nsl.com/misc/k/kwin.zip 00:39:20 there's your interpreter 00:39:42 i'm actually on ubuntu. 00:40:46 lol thank you xchat, there's no way to copypaste that into my url without the kwin.zip part xD 00:40:51 klin then 00:41:17 now WHERE is my goddamn interpreter for os x 00:43:53 http://www.kx.com/download/download.htm sdfhsdfoijsdfoihsdf no k interpreter 00:44:22 anyway 00:44:25 explain k-trees, oklopol 00:45:34 anyway. fact:[*1|_] 00:45:40 there's a factorial 00:46:12 whellll the k-tree is a tree 00:46:18 which holds the vars 00:46:31 helpful 00:46:45 the point is you can do scopes explicitly in a fun fashion by executing something in a lower branch 00:47:59 so how do i use a k-tree in place of pattern matching 00:48:15 umm... there's no "a k-tree" 00:48:19 there's only one k-tree 00:48:21 ok 00:48:26 how do i use it in place of pattern matching 00:48:34 depends what you mean. 00:48:42 ohhhhh 00:48:56 when i said "k-tree <3", it had nothing to do with pattern matching. 00:50:01 uhhh 00:50:03 k 00:50:03 + 00:50:05 erlang 00:50:06 = 00:50:08 sex. 00:50:31 kinda like pi calculus, but... less calculus'y :-) 00:50:57 something involving a linda-like global tuplespace 00:50:58 so, oklopol... 00:51:04 what? :) 00:51:05 how should we do conditionals/pattern matching/whatever 00:51:24 ah, well, *that* i don't know. 00:51:32 all i know is, k+erlang, maybe? 00:51:33 :)) 00:51:52 i have no idea what that even means, i just know it's awesome. 00:52:22 actually, i should learn linda, since i just know it has the global tuplespace, and that's awesome :P 00:52:38 :/ 00:52:52 sorry for not being helpful, my brain isn't good at anything non-random ideas thinking at this hour. 00:53:09 i'd need longer vacations to get used to the fact i sleep during the day :) 00:53:27 hm the evaluation model of our language is still pretty standard 00:53:38 maybe there's a way to make code more consice, by completely changing it 00:55:14 well, you could make it point-free, and add lots of high-order functions :)) 00:55:24 i'm going to sleep soon 00:55:27 too many smileys. 00:55:28 heh 00:55:33 point-free code isn't consicer though 00:55:46 not really, no 00:55:47 certainly not quicker to write either 00:55:56 certainly not, no 00:55:58 :)) 00:56:54 oklotalk isn't hard to win, since i've let a lot of stuff out i originally had, for lessening obscurity :< 00:57:31 so, the language 00:57:46 if the aim is for conciseness, i'd start with examples 00:58:04 i mean, examples of programs we want to be concise. 00:58:32 it's pretty simple to find a language that would be most concise for doing a certain kind of job 00:58:53 well, ofc not *the most concise one* 00:59:05 but, like, very. 01:00:21 aim is for conciseness and speed to write 01:01:27 well, one way to be concise is to leave more stuff for the interp to figure out 01:01:40 make it a bit more declarative 01:01:53 ok 01:01:57 example? 01:02:10 one way to do this would indeed be the tuple space, i think... although that is only a feeling, since i haven't explored it that rigorously.. 01:02:13 hmm 01:02:32 well, i can give you extreme examples, ones that are fully declarative... 01:03:23 like ![{a for sorting 01:03:41 ![] means "do something that makes this return true" 01:03:52 ooh 01:03:56 let's devise an algorithm for sorting 01:03:57 that is 01:03:58 1. fast 01:04:00 then \2\, here, was a reduce that took 2 at a time 01:04:06 2. extremely concise when expressed declaratively 01:04:09 and the rest is trivial 01:04:43 also, that ![...] stuff 01:04:45 for that 01:04:48 will be uh... 01:04:50 hard for the interp 01:04:53 specifically, near-brute-force 01:05:31 anyway, let's do what i said 01:05:33 indeed. 01:05:51 i said i can only concoct an extreme example in a short time. 01:06:10 you can so something in-between 01:06:23 :-) 01:06:26 hmmmm 01:06:28 hm 01:06:35 what about improving mergesort, then making it declarative 01:06:44 specifically, i'm thinking running the branches concurrently 01:07:13 indeed, a lot of support for cutting and splicing lists, and recursion! 01:08:21 declarative recursion 01:08:24 you figure that one out :-) 01:09:15 wait wait 01:09:19 i'm close to it. 01:11:03 ooh 01:11:06 :-) 01:11:16 i'm having a hard time coming up with a syntax. 01:11:22 did you find something? 01:12:28 rec l\2, zipx .<< 01:12:55 let's say that's a function, l\2 splits a list [1, 2, 3 ,] 01:12:57 eh... 01:13:22 let's say that's a function, l\2 splits a list [1, 2, 3, 4, 5] -> [[1, 3, 5], [2, 4]] 01:13:55 rec is a lower precedence high-order function that applies current function recursively for every item in a list 01:14:02 in this case the two halves of the list 01:15:01 , is a low precedence function that works as a data flow controller, it takes the output of the last thingie and gives it to the next. this could just be done using normal application, but i think the precedences may provide more conciseness with a comma oper. 01:15:48 zipx takes a function and a list of lists, and always zips the value the function gives from all the heads of the lists given to it as a list, and concatenates one at a time 01:16:15 these are all very basic functions, so i think that could be made 8 or 10 chars. 01:16:30 this is not declarative 01:16:46 nope. 01:16:47 just an idea. 01:17:01 the declarative one i had was less concise :P 01:17:11 list splicing is sooooo mucho fun 01:17:27 anyway: [$_\2,!] 01:17:31 hmm 01:17:33 anyway 01:17:36 what is that 01:17:37 is that a sorter 01:17:45 what is what 01:18:51 anyway 01:18:58 here's a quicksort idea: 01:20:02 '\_2,)#<< 01:20:35 hm 01:20:36 wait 01:20:43 tell me the syntax for car and cdr 01:20:46 one-char, prefix 01:21:14 i use . and : usually 01:22:12 ok 01:24:47 qs^naive:[l:r:(). :?_<2[_][p:#_ ?_/2. [:_ oklopol: imperative-style quicksort 01:25:10 you can figure it out. it's not hard 01:25:29 watch out for : being both a 3-arity prefix and a 2-arity infix 01:26:05 qs^naive:[l:r:(). :?_<2[_][p:#_ ?_/2. [:_ missed a . 01:26:18 qs^naive:[l:r:(). :?_<2[_][p:_#?_/2. [:_ made # infix 01:26:26 that's not very concise + i'm not sure i can read it. 01:26:26 oklopol: take a look at that 01:26:35 its not concise cause it's imperative 01:26:38 i'll walk you through it 01:26:39 qs^naive:[l:r:(). :?_<2[_][p:_#?_/2. [:_ x:y is assignment 01:26:48 ah 01:26:53 l:r:() is like l = r = [] 01:27:00 () just being the null expression 01:27:12 since scalars = list 1-order, 01:27:15 null = list 0-order 01:27:17 mine was imperative and 9 characters :) 01:27:23 then we have 3-arity : 01:27:28 but okay 01:27:32 and yes but mine's not relying on bizzare things 01:27:36 ?_<2 01:27:37 neither is mine. 01:27:38 ? is length 01:27:42 ?_ being length of the arg 01:27:45 checking <2 01:27:50 if so, we just return it - [_] 01:27:59 otherwise, pick a pivot from the middle - ary#index 01:28:16 then, run [:_ if _ is less than the pivot, append it to l 01:28:25 ~ is concat 01:28:28 otherwise, append it to r 01:28:34 then, qs l and r and concat them together 01:28:47 so what's your qs? 01:28:53 it's not fully imperative really 01:28:58 thought so 01:29:14 qs is much harder in my lang stub. 01:29:31 '\_2,)#<< 01:29:33 walk me through 01:29:49 i already did, but i'll redo that 01:30:02 wait, it's not qs 01:30:05 it's brute-force sort 01:30:06 :-) 01:30:10 it's mergesort 01:30:33 also, it's a parametrizable mergesort of any amount of splits 01:30:44 it's also slow 01:30:50 turning \ into / will make another mergesort, which runs a bit faster 01:31:00 nope, yours copies the list too. 01:31:33 ok walk me through it 01:31:35 each char 01:31:54 okay, first split by ',' to get the statements 01:32:00 ok 01:32:01 '\_2 01:32:03 and )#<< 01:32:24 "'" there is a special recursion tool that applies recursion to each sublist, unless an empty list, which is simply returned 01:32:28 this is a frequent need. 01:32:35 it's a deep mapping. 01:32:38 basically 01:32:40 ok 01:32:44 and \_2 01:33:13 \ is a prefix splice here, _ is the nameless arg given to the substatement, so it will basically be cut in two halves in the first statement 01:33:26 then, the recursion applies 01:33:26 prefix splice? sounds pretty specific to me 01:33:35 err... 01:33:36 ok, wht's )#<< and why does it have unmatched 01:33:44 cutting a list into pieces is what i based the idea on. 01:33:51 ok 01:33:54 )#<< 01:34:41 yeah, that will take the resulting list, )# is, kinda like ', a special prefix transformer, that takes a list, and concatenates using the function given to decide which one pick at each time. 01:35:05 that's pretty spesific, but there are enough 2-char tokens to have that kind of stuff, especially when you can overload. 01:35:11 << is just a min function 01:35:51 it would be just <, in case of type inference, where < can be min when a non-boolean is expected and normal ordering function int->int->bool when a bool is expected. 01:36:00 how about we define a problem domain to work on 01:36:03 then base the language on that 01:36:17 let's think low-level: what essentially are most algorithmic programs? 01:36:24 Let's take the factorial. 01:36:31 Isn't it a map? 01:36:37 yeah 01:36:39 An infinite map. 01:36:43 yarrrr 01:36:46 So.. 01:36:57 If [] is a mapping, 01:37:03 [x=y. x=y] etc 01:37:11 hmmm 01:37:14 then 01:37:16 [] is a mapping? 01:37:20 errr 01:37:20 we can algorithmically define how to look up a key 01:37:25 what kinda mapping, now? 01:38:03 fact = [_<2 = 1; n = n * fact(n-1)] 01:38:07 do you see? 01:38:13 it's just a dictionary, mapping, hash table, thing 01:38:17 but you can define keys algorithmically 01:38:24 and they are lazily called upon 01:38:29 fact(n-1) is just a table lookup 01:38:36 a function is just a table 01:38:37 well yeah, that's how oklotalk would do it 01:38:41 no 01:38:43 because it's still a function 01:38:48 it's still called and returned from, etc 01:38:54 ? 01:38:59 let's put it this way 01:39:02 there are no functions 01:39:06 _<2 isn't a pattern match as such 01:39:06 oklotalk doesn't differentiate between lists and functions... 01:39:11 it doesn't match on an 'argument' 01:39:24 i see, it's the same thing, essentially, though? 01:39:26 it simply states that in the fact table, lookups < 2 = 1 01:39:30 that is: it's a hash table 01:39:35 yes, a function 01:39:36 you don't 'execute and match' 01:39:40 you 'lookup' 01:39:49 that's exactly how functions do it, pattern match and return. 01:39:50 please understand the philisophical difference 01:39:54 no 01:40:04 how' 01:40:06 please think about it 01:40:15 it's a different way of thinking about it 01:40:19 instead of factorial being an algorithm 01:40:23 it's just a lookup table: 01:40:33 yes, exactly the idea behind pattern matching. 01:40:46 [0 = 1; 1 = 1; 2 = 2; 3 = 6; 4 = 24; ...] 01:40:52 don't think of it as matching 01:40:53 but, oklotalk does exactly what you're thinking there, makes function basically an infinite list. 01:40:57 think of it as all keys are evaluated already 01:40:58 or a hashmap 01:41:05 don't think of fact(n) matching 01:41:05 yes, the oklotalk way. 01:41:08 period. 01:41:11 just think of it looking up an already infinite table 01:41:23 yes, the *exact* idea behind oklotalk's functions. 01:41:33 no, because you don't reason about it like a function 01:41:41 k. 01:41:42 you reason about it like a pre-computed table 01:41:48 like everything is constant 01:41:49 ah, kinda like in oklotalk. 01:41:55 kind of, but not exactly 01:42:05 oklotalk still makes you think about calling and returning, etc 01:42:41 yes, it lets you do that if you want, i'm just saying that's nothing new, pattern matching is equivalent to that... 01:43:09 except for the possible built-in functions that might handle it differently, but you can do that for functions too 01:43:15 yes, the method is equiv 01:43:17 the reasoning isn't 01:43:21