2003-08-12.txt:18:56:53: <Taaus> But I really don't like reading books on my computer. I prefer dead-tree versions :)
2003-09-08.txt:13:44:35: <Doppelganger> Verbed: wn, web1913, and devils reciping: web1913: Extremely \Es`o*ter"ic\, a. Morosity be sacristy our perhaps; providencer's; salestrimmer; confederate; as, an eshtree provost; any estarr meeting; wn: extraomnes attack : convenient to and under be only an emulously inner caraculacticors; "a completed of ester palseyputred there's" [ant: {exoteric}]; web1913: Eggdrazzles (4 more messages)
2004-05-04.txt:00:52:52: <andreou> (plus, i would have to break the chroot or create a local tree with perl+libs)
2004-05-04.txt:01:04:48: <Toreun> I'm thinking for organizing wiki link trees and other random stuff?
2004-05-04.txt:03:52:30: <andreou> hm i need something that won't need a whole libc+perl tree
2004-06-25.txt:09:15:40: -!- andreou has quit ("A tree excells at being a tree.").
2004-06-25.txt:11:20:43: -!- andreou has quit ("A tree excells at being a tree.").
2004-06-25.txt:11:46:13: -!- andreou has quit ("A tree excells at being a tree.").
2004-06-25.txt:15:57:08: -!- andreou has quit ("A tree excells at being a tree.").
2004-06-25.txt:20:36:01: -!- andreou has quit ("A tree excells at being a tree.").
2004-07-12.txt:21:04:32: <mtve> usually it's a recursive parser that returns tree of operations.  then you build your code by walking the tree.
2004-07-12.txt:21:04:52: <calamari_> right, but it builds the wrong tree
2005-02-25.txt:05:06:12: * heatsink is reading about red-black trees
2005-02-25.txt:05:06:41: <heatsink> My neighbor had a tree that was kinda red-black.
2005-03-11.txt:03:54:52: <{^Raven^}> and I'm just integrating Easel into the new source tree
2005-04-13.txt:14:14:28: -!- Treemole has joined #esoteric.
2005-04-13.txt:14:14:54: -!- Treemole has quit (Client Quit).
2005-05-04.txt:19:38:08: <GregorR-L> If that logic tree is to totally random to decipher, tell me, I might be able to change it around a bit :-P
2005-05-04.txt:21:01:28: <GregorR-L> Umm, possibly.  I could definitely fix the logic tree of doom ^_^
2005-05-06.txt:22:59:14: * KnX wants tree-oriented Mozilla tabs
2005-05-22.txt:01:14:36: <calamari_> kipple: just looked because I was curious about MoinMoin.. it stores the pages in a directory tree
2005-05-26.txt:15:18:25: <pgimeno> instead of one plus a tree
2005-05-26.txt:15:19:11: <kipple> and you could put the db-dumps in the file tree, and do it in one op
2005-05-26.txt:15:23:32: <malaprop> pgimeno: I think he was saying the svn dump should be copied into the wiki tree.
2005-05-26.txt:15:25:47: <malaprop> That will be in the wiki tree, we've already planned for it.
2005-05-26.txt:16:09:28: <pgimeno> you can download the subversion tree with wget via web, for example
2005-05-26.txt:23:26:41: <pgimeno> graue: that's not bad for tarball distributions; it's bad for tree structures à la Cat's Eye
2005-05-27.txt:00:17:08: <graue> you would checkout svn, copy a file into your tree and svn add it
2005-05-28.txt:18:52:03: <kipple> well, if svn doesn't have a problem with the wiki writing into the file tree, then that would work
2005-05-29.txt:13:14:47: <jix> i tokenize the code into a linked tree and the loop instruction forks the tree
2005-05-29.txt:14:04:41: <jix> uh.. i thought it was the interpreter.. but it was the token-tree-freeer
2005-05-29.txt:15:01:45: <jix> i wrote a small debug feature that allows me to dump out the token-tree (the output is valid kipple)
2005-06-03.txt:22:32:13: <pgimeno> someone said recently in the GMP mailing list: 'C' gives you enough rope to hang yourself, and will even do the favor of throwing one end of the rope over the tree for you ...
2005-06-07.txt:00:00:56: <pgimeno> do you want to add the whole src/ tree with all of its contents?
2005-06-09.txt:10:45:11: <DMM> indeed he has. A lot of tree-based ones though...
2005-06-17.txt:21:49:57: <pgimeno> c:ppddcust.exe /name="John Doe" /address="666th street, Moon" /phone="(+12)3456789"
2005-06-21.txt:17:55:51: <graue> how about a homeless kid finds a discarded laptop on the streets of a city slum, connects to an unsecured wireless network, and begins learning about esoteric programming languages?
2005-07-24.txt:21:56:37: <jix> and some o11s within the loop tree
2005-07-24.txt:22:32:30: <jix> 1 that works on the brainfuck source 1 that does the bf-tree => intermediate-lang and 1 that removes dead code from the intermediate-lang
2005-08-21.txt:05:28:07: <tokigun> i'm planning (or thinking) esolang which uses binary tree as data structure. there's such the esolang?
2005-08-21.txt:05:29:09: <WildHalcyon> Im not familiar with any esolang that uses trees. A generic binary tree, or do you have a more specific one in mind?
2005-08-21.txt:05:29:49: <tokigun> i mean generic binary tree... maybe.
2005-08-21.txt:05:30:50: <tokigun> each node has one integer as data, and the program travels the tree.
2005-08-23.txt:06:06:56: * calamari hides from WildHalcyon's B-Tree
2005-08-23.txt:06:07:24: <WildHalcyon> you think a B-Tree is the worst up my sleeve?
2005-08-23.txt:06:09:16: <WildHalcyon> right now, Im debating between a treap, a k-d tree, and a pairing heap
2005-08-23.txt:06:15:53: <WildHalcyon> Yeah, I like k-d trees
2005-08-23.txt:06:32:04: <nooga> what are k-d trees?
2005-08-23.txt:06:37:59: <WildHalcyon> Right, essentially, a 2-d tree has two types, a 3-d tree has three types to search among, etc.
2005-08-23.txt:06:38:40: <calamari> hope that makes some kind of sense.. I have no really studied these trees :)
2005-08-23.txt:06:40:35: <WildHalcyon> That's pretty much it. At each level of the binary tree, sort based on different types of data
2005-08-23.txt:06:43:14: <calamari> but you'll also want to be able to manipulate the tree
2005-08-23.txt:06:57:20: <calamari> hmm, maybe it's just been too long since data structures, but it doesn't seem like trees and arrays really mix, unless it's a non-bst
2005-08-26.txt:04:18:44: <WildHalcyon> Yeah, its a type of binary tree with some heap properties
2005-09-18.txt:17:40:38: <Wildhalcyon> Im not sure how that integer sequence (which deals with anti-chains in "rooted trees" ?) relates to the symbol problem though
2005-09-18.txt:18:05:05: <Wildhalcyon> Im trying to design a tree structure out of it, but its difficult
2005-09-20.txt:04:46:12: <Arrogant> As well as operators for walking up and down a scope tree
2005-09-27.txt:22:35:35: <Wildhalcyon> I like street cred
2005-09-27.txt:22:35:53: <GregorR-L> But it's street cred associated with Microsoft.
2005-09-27.txt:22:36:09: <GregorR-L> That's like the street cred from being a Visual Basic guru :-P
2005-10-07.txt:19:56:59: <jix> for a hash trees tables... the coverage over all bits is important
2005-10-11.txt:05:52:06: <nooga> if we have strong wind here, it can break a tree or take crappy roof away
2005-10-28.txt:23:08:46: <Aardwolf> well meanwhile, check out this :) http://www.rense.com/general67/street.htm
2005-10-30.txt:15:05:05: <fizzie> In London the 'hybrid' view used to have the streets few metres off the satellite view, let's see if they still have that problem...
2005-10-31.txt:22:05:04: <calamari> wow the streets to the left of GregorR's pointer look like a navigation nightmare
2005-10-31.txt:22:05:35: <kipple> hmm. if you zoom in on the satelite map you can see that Gergor lives under a tree. 
2005-10-31.txt:22:13:15: <Robdgreat> A Moxie tree, no doubt.
2005-11-14.txt:23:51:09: <calamari> string -> tree
2005-11-15.txt:14:10:14: <kipple> seen this: http://skystreets.kaosfusion.com/ ?
2005-11-25.txt:20:11:51: <jix> there was a way to dump the gcc gimple tree (for making a c => linguine compiler)
2005-11-25.txt:23:16:37: <jix> that's a tree build from ruby arrays.... not a program...
2006-01-04.txt:20:53:07: <ihope> I'm trying to write a Haskell interpreter for it. Treeky, it is.
2006-01-07.txt:04:55:22: <fizzie> Well, you can easily have a 'choose your own adventure'-type of story tree thing (or other forms of 'choose from a predefined set of options, do decisions based on that'), but that's about it. (As far as I know, and the specs are oh-so-secret - there are few pages on the internet, and the dvdauthor documentation and source.)
2006-01-27.txt:19:12:55: <nooga> he doesn't know how to implement tree walking 
2006-01-27.txt:21:22:32: <Keymaker> ..and what is tree walking?
2006-01-27.txt:21:23:04: <jix> you have a tree (data structure) and you visit all nodes in some order
2006-02-01.txt:01:42:32: <GregorR> If you divide up the parse tree enough and make liberal use of temporary variables, it shouldn't be such a huge problem.
2006-02-01.txt:20:46:23: <GregorR> Maybe I ought to bark up that tree.
2006-02-02.txt:15:27:31: <{^Raven^}> all the changes are in the bfbasic CVS tree
2006-02-02.txt:23:23:08: <GregorR-L> I need to get my AST tree generator done so you can play with C2BF instead 8-D
2006-02-03.txt:16:34:54: <ihope> "Rough-coated, dough-faced, thoughtful ploughman John Gough strode through the streets of Scarborough; after falling into a slough on Coughlin road near the lough (dry due to drought), he coughed and hiccoughed, then checked his horse's houghs and washed up in a trough!"
2006-02-04.txt:06:44:59: <GregorR> So in this compiler's parser, I have a bunch of nonterminals.  I have 14 left to make a tree out of.
2006-02-07.txt:05:17:34: * Arrogant plays some Porcupine Tree
2006-02-08.txt:06:27:37: <GregorR> There are for CST (concrete syntax tree)
2006-02-21.txt:15:21:39: <nooga> i'm looking for a way to check if a tree is a subtree of another
2006-02-21.txt:15:23:57: <nooga> binary tree
2006-02-21.txt:15:24:09: <SimonRC> isSubTree n m@(Node _ l r) = n == m || n `isSubTree` l || m `isSubTree` r
2006-02-21.txt:15:25:56: <nooga> i've got a tree in such format
2006-02-21.txt:15:29:41: <nooga> trees
2006-02-21.txt:15:30:05: <SimonRC> They look like lists, not trees
2006-02-21.txt:15:44:04: <SimonRC> what's your tree type?
2006-02-21.txt:15:44:46: <nooga> make it compatible with:  isSubTree n m@(Node _ l r) = n == m || n `isSubTree` l || m `isSubTree` r
2006-02-21.txt:15:45:43: <SimonRC> data Tree a = Node a (Tree a) (Tree a) | Nil
2006-02-21.txt:15:48:05: <SimonRC> erm, what data do you want in your trees?
2006-02-21.txt:16:31:05: <nooga>     In the definition of `isSubTree':
2006-02-21.txt:16:31:05: <nooga>         isSubTree n (m@(Node _ l r))
2006-02-21.txt:16:31:05: <nooga>                     = (n == m) || ((n `isSubTree` l) || (m `isSubTree` r))
2006-03-10.txt:15:49:52: <jix> you have a tree like structure
2006-03-11.txt:15:15:21: <SimonRC> but, you can make a function be parsed like a variable (being a leaf not a branch node in the parse tree) or a variable act like a function (be a branch not a leaf in the parse tree)
2006-03-11.txt:23:00:48: <Arrogant> Porcupine Tree is my favorite.
2006-03-18.txt:19:54:24: <calamari> and I used GIMP to remove a street sign
2006-04-05.txt:19:35:52: <nooga> haj maj frriendz from foregin kauntrees
2006-04-28.txt:18:54:14: <nooga> like tree or even soda can 
2006-04-28.txt:18:54:28: <GregorR-W> More like a tree :P
2006-04-29.txt:00:03:26: <kate`> imagine you have a jpeg: the first thing you do is parse it into a tree
2006-04-29.txt:00:03:34: <kate`> when you're done, you serialise that tree back to a file
2006-04-29.txt:00:03:47: <kate`> why not store the parsed tree in the first place?
2006-04-29.txt:00:10:06: <kate`> kipple, your XML document is not a bunch of ascii: it's a DOM tree
2006-05-24.txt:20:31:24: <calamari> a couple days ago we drove up north for a funeral and the changing landscape (how the trees changed with elevation, etc), reminded me of my adventure game
2006-05-30.txt:22:09:30: <ihope> Then we can represent trees easily enough: 0 is S, 1 is K, 1+(x,y) is `xy.
2006-06-01.txt:16:36:34: <ihope> I say <parens> ::= "(" <parentree> | epsilon, and <parentree> ::= "(" <parentree> <parentree> | ")".
2006-06-01.txt:16:37:17: <ihope> So a set of parentheses is pretty much a list of trees of nothing in particular.
2006-06-05.txt:14:57:47: <ihope> Just parse all your input, using the "reprint character read" function to deal with the output functions. Then use a fold to turn the resulting tree into Unlambda code, and have the rest of the interpreter evaporate.
2006-06-06.txt:14:05:03: <fizzie> That thing is so very fancy; now if they'd just allow drag-n-dropping the DOM nodes in the tree.
2006-06-14.txt:23:26:27: <ihope> Now, if I'm not mistaken, it is easy for Unlambda to simulate Unlambda: just construct a tree with all your primitive thingies, then fold them into a function, which is your program.
2006-06-23.txt:22:34:39: <_W_> trees are so much simpler :(
2006-06-24.txt:22:39:37: <SimonRC> IIRC you can right-click on anything in the source tree in Netbeans and hit update to get it check for external changes
2006-07-25.txt:09:31:25: <Arrogant> Jay: Kids, if Silent Bob could talk, he'd remind you that when you're camping, it's always smart to tie your food up in a tree at night so as not to attract bears.
2006-07-31.txt:14:29:01: <GregorR> I had to use pstree O_O
2006-08-05.txt:03:55:33: <RodgerTheGreat> use dimensions like a tree structure.
2006-08-05.txt:03:57:23: <RodgerTheGreat> now, to actually store this as a data structure, you'll need a treelike system.
2006-08-05.txt:06:00:40: <RodgerTheGreat> [10:55pm] RodgerTheGreat: use dimensions like a tree structure.
2006-08-05.txt:06:00:58: <RodgerTheGreat> [10:57pm] RodgerTheGreat: now, to actually store this as a data structure, you'll need a treelike system.
2006-08-06.txt:02:02:04: <RodgerTheGreat> although, from a programmer's standpoint, it'd be equivalent to a tree... I wonder if it would make sorting algorithms easier to implement...
2006-08-15.txt:03:52:59: <RodgerTheGreat> I'd describe his topology as more 3d- a tree structure consisting of arbitrarily large 1D nodes.
2006-08-16.txt:01:39:00: <oerjanj> sesame street style then?
2006-08-20.txt:14:48:20: <pgimeno> "What if you're in a street and there's a bull coming towards you?" "I'd climb to a fence" "And if there's no fence?" "I'd look for a shop or something" "And if there's no shop" "I'd try to run to the closest corner" "And if there's a wall?" "I'd try to jump it" "And if it's too high?" "Hey, what you want is me to be caught by the bull!"
2006-08-24.txt:23:00:59: <jix> well c uses 2 different tree representations...
2006-08-29.txt:01:25:38: <GreyKnight> It's basically impossible for the computer to misparse your Lisp code, because the parse tree is there in the language itself ;-)
2006-08-30.txt:05:32:31: <GreyKnight> SHDMEABNFWXYZ-andapartridgeinapeartree
2006-08-31.txt:22:44:02: <ihope> My interpretation: the vertices must form a tree, and each edge must have a name such that there can't be two edges with the same name on one vertex.
2006-08-31.txt:23:47:46: <GreyKnight> how about as a binary tree? 'o'
2006-09-01.txt:00:58:35: <Razor-X> Uggh. Trees annoy me.
2006-09-01.txt:00:59:07: <Razor-X> Although if you want an INTERCAL-esque language, trees are the way to go ;).
2006-09-01.txt:01:00:02: <GreyKnight> I think a binary tree might be pretty useful here
2006-09-01.txt:01:00:05: <Razor-X> I guess if you want to search for something in a data structure recursively, trees are useful, but other than that.....
2006-09-05.txt:23:19:42: <pikhq> In fact, it's sufficient for plotting a full family tree.
2006-09-06.txt:07:36:24: <Razor-X> I'd hesitantly call the binary tree an advanced data structure, but I accept it. Still.... stacks?
2006-09-06.txt:07:36:42: <GregorR> I'd put a binary tree JUST under the advanced line.
2006-09-09.txt:02:30:16: <pikhq> I'll make another tarball soon as I bother cleaning up my current source tree.
2006-09-10.txt:03:15:02: <pikhq> Been fixed in my local tree for days, but the last tarball was made long before that.
2006-09-18.txt:23:45:00: <feesh> I dunno I met him on the corner of my street
2006-09-22.txt:20:59:46: <Asztal> You could use Morton numbers for keys in a binary tree
2006-09-22.txt:20:59:55: <Asztal> but, I've yet to see a binary tree in INTERCAL
2006-10-22.txt:21:15:52: <jix> one of the big advantages is that there is no sorting involved... you can work right from the probabilities... no need to generate a tree... that makes it faster for adaptive encoders
2006-10-23.txt:19:39:38: <jix> Today, we are handle decreased the daily newspaper of the first boat splendourful, [[“iynfwrm' ayshnsbwryfyk' ayshndyrktyfn]]. This traction outside of ours street, initially examined in the team [[hystwryn]], garden, request for divine the blessings the clean dish. [“ammnt] the truth causes complexes [[, the jam of the pain of the mwtsGnd]] with the all workmen, when it flowers. Us it country of the family of the state of the family of the idea
2006-10-23.txt:19:45:46: <jix> Today, we are decreased joystick the daily newspaper of first splendourful ship, [[“iynfwrm'ayshnsbwryfyk'ayshndyrktyfn]]. This pull outside from ours street, first examined in team [[hystwryn]], garden, prays for divine the benedictions the clean dish. [“ammnt] causes complex truth [[, the jam of pain of mwtsGnd]] with the all workers, when it blooms. Us the country of family of condition of family of idea of connection of troops of arm acquain
2006-10-23.txt:19:47:40: <GregorR-L> This pull outside from ours street ...
2006-10-28.txt:22:43:49: <oerjan> one thing that may not be apparent at the beginning is that the solutions always have a tree structure
2006-11-19.txt:22:35:20: <SimonRC> You go up the tree, then down.
2006-11-19.txt:22:36:03: <SimonRC> Of course, it's nothing like a tree really, but the addresses *are* assigned so that you can abbreviate the routing table and still get very good results
2006-12-02.txt:02:09:19: <bsmntbombdood> Maelzel, who bade me pleasant weather the eyelids were it will be sure trader, I believed from tree stood a man whipped syllable!
2006-12-02.txt:22:28:07: * SimonRC finds some clever code to flatten a Scheme-style tree:
2006-12-10.txt:22:22:02: <calamari> SimonRC: yeah.. the hard part at least for my brain is building some kind of tree or such
2006-12-10.txt:23:53:46: <oerjan> one idea is to encode the label in binary and use a branching tree for the case statement
2006-12-20.txt:17:11:47: <bsmntbombdood> I think I'm goign to ski down my street later
2007-01-01.txt:20:38:37: <pikhq> There'd be no actual *tree* in such an FS.
2007-01-01.txt:21:59:06: <CakeProphet> fuck trees.
2007-01-01.txt:22:01:09: <ihope_> Why did he do from the trees? I don't know through it.
2007-01-01.txt:23:36:23: <ihope> CakeProphet: a compiler turns BF into something else, then runs it. An interpreter turns it into a list/tree/thing of instructions and runs through those.
2007-01-03.txt:20:58:05: <CakeProphet> So thinks like variable names, call stacks, evaluation stack, parse trees, and language syntax should all be expressable by data of some sort.
2007-01-03.txt:21:24:16: <SimonRC> once the forms are read it, there is compile time, which IIRC starts with macro-expansion, which allows you to pass parts of parse trees (s-expressions) through arbitrary functions, which it handy.
2007-01-11.txt:01:35:33: <oerjan> The Data.Map library uses binary trees.
2007-01-11.txt:01:46:23: <oerjan> or possibly pointers to binary trees, I guess.
2007-01-12.txt:01:52:41: <CakeProphet> "(" simply means accumulate another branch to the parse tree...  ")" mean return to the last node... "  and '  would start a string and symbol mode respectively.
2007-01-12.txt:02:11:38: <bsmntbombdood> I'm not sure what the parse tree should look like
2007-01-12.txt:02:37:12: <oerjan> And by the way, this is easiest in functional style: the result value of the function should be the parse tree of what that invocation has parsed.
2007-01-12.txt:03:11:29: <oerjan> You are missing a tree.append(buff) before the return.
2007-01-12.txt:05:45:42: <bsmntbombdood> It parses python into syntax trees
2007-01-12.txt:05:53:22: <bsmntbombdood> You can write python as syntax trees :)
2007-01-13.txt:23:34:24: <RodgerTheGreat> has anyone made a good tree implementation in BF?
2007-01-15.txt:23:13:16: <pikhq> Not counting my C backend, which I have yet to sync in with the rest of my tree.
2007-01-18.txt:01:26:24: <CakeProphet> I wonder how you would use a tree as a languages data structure.
2007-01-18.txt:01:27:10: <oklopol> you can have tree data structures as vars then
2007-01-18.txt:01:27:54: <CakeProphet> and trees.
2007-01-18.txt:01:28:36: <CakeProphet> you could take a lisp-ish approach and make the program a tree.
2007-01-18.txt:01:29:18: <oklopol> you could just code it as a tree, no ascii shit
2007-01-22.txt:00:26:29: <oklopol> the tree-parsing was not explained at all
2007-02-01.txt:22:18:48: <SimonRC> abstract syntax tree
2007-02-08.txt:01:23:26: <ihope_> You need a way to represent trees in C.
2007-02-08.txt:01:24:22: <bsmntbombdood> tree as in sexp?
2007-02-08.txt:01:30:43: <ihope_> That's a tree with either S or K at each leaf?
2007-02-08.txt:01:31:59: <bsmntbombdood> that's a tree with either S or K at each leaf
2007-02-11.txt:02:54:57: <SevenInchBread> since Lisp code is just like... a parse tree.
2007-02-11.txt:22:22:40: <bsmntbombdood> yacc should build a parse tree implicitly to give to you after parsing
2007-02-14.txt:18:46:21: <GregorR> oerjan.ooTree.reasonable = false;
2007-02-14.txt:18:48:07: <oerjan> Language.Haskell.ModuleTree /= ObjectOriented
2007-02-14.txt:21:05:15: <oklopol> i have one in c++ that does nice circular tree structures
2007-02-17.txt:02:18:54: <oerjan> And if you reduce the Ei expressions recursively to their head normal forms (or to V if they don't have any) then you get a tree structure which may sometimes be infinite.
2007-02-17.txt:02:22:47: <oerjan> Bõhm trees.
2007-02-20.txt:23:27:18: <SevenInchBread> It's basically a binary tree of arrays of characters (a tree of strings).
2007-02-22.txt:17:34:59: * oerjan thinks his data structure for implementing V's sum tree was moderately clever. :)
2007-02-22.txt:17:37:43: <ais523> You have a structure consisting of a binary tree and a linked list of binary trees?
2007-02-22.txt:17:38:51: <oerjan> well, i guess you could call it that.  It's just a zipped binary tree.
2007-02-22.txt:17:39:54: <ais523> For Underload's superset language, Overload, I'm using a data structure which is effectively a doubly-linked binary tree
2007-02-22.txt:17:40:29: <SimonRC> ITYM "binary tree with upward links".
2007-02-22.txt:17:40:57: <ais523> because the trees are also infinite
2007-02-22.txt:17:46:14: <oklopol> oaky could be the name of a tree-based lang
2007-02-22.txt:17:46:59: <ais523> how does this tree-based language work, then?
2007-02-25.txt:02:27:40: <ihope> bsmntbombdood: fancy spelling of "tree", isn't it?
2007-02-25.txt:02:28:59: <oerjan> not quite.  A trie is a special kind of tree, in which every key has a specific place in the tree, known at the outset.
2007-02-25.txt:22:07:42: <oerjan> basically, if there is only one leaf in a subtree, you save it directly.
2007-02-25.txt:22:07:53: <oerjan> at the top of that subtree.
2007-03-04.txt:00:35:49: <SimonRC> with clever sharing, a number could easily be a tree with NILs at the leaves
2007-03-04.txt:00:36:08: <SevenInchBread> so then concatenation of the trees would be like addition.
2007-03-12.txt:16:19:52: <oerjan> Trees.
2007-03-17.txt:01:28:16: <oerjan> I found a downloadable Data.FingerTree module in which you can select any Monoid as your size measure.
2007-03-17.txt:01:54:52: <bsmntbombdood> FingerTree!
2007-03-19.txt:00:10:41: <oklopol> even though i was thinking about tree cones
2007-03-20.txt:18:14:34: <oklopol> well, the string could hang from a tree, and trees can grow
2007-03-20.txt:18:16:40: <ais523> apple tree -> apples -> rotten apples -> seeds -> more apple trees (unboundedly); apple tree -> wood -> box (when it stops producing apples); so all you need is the string and an infinitely large orchard, as you can get the apple tree from the rotten apples
2007-03-20.txt:18:21:34: <RodgerTheGreat> perhaps all that's necessary is using the life cycle of the trees for computation
2007-03-20.txt:18:22:19: <RodgerTheGreat> the survival and reproduction of trees as they compete for space is your computational system
2007-03-20.txt:18:22:41: <ais523> I'd like to see an apple-tree implementation of Life. It would be kind of appropriate.
2007-03-20.txt:18:23:05: <jix> hmm apple trees should be renamed to iTrees
2007-03-20.txt:18:23:40: <RodgerTheGreat> oerjan: the string could be used, but just trees in dirt seems more elegant
2007-03-22.txt:01:29:18: <SevenInchBread> hmmm... representing files as linked lists allows you to create infinite files - and tree structures.
2007-03-22.txt:11:41:01: <SimonRC> so you have a netwok rather than a tree
2007-03-22.txt:11:48:46: <SimonRC> a sort of cross between a big directory tree and a collection of DB tables
2007-03-22.txt:11:52:11: <SimonRC> BF programs are basically trees of strings of "<>+-,.", right?
2007-03-22.txt:22:57:30: <SevenInchBread> hmmm... I think it makes more sense to represent concatenations as trees... instead of just returning the combined result.
2007-03-25.txt:21:57:02: <SevenInchBread> the "parens" of the parse tree. ;)
2007-03-25.txt:22:53:15: <oklopol> i'd not save the name of a var anywhere even if just making a parse tree
2007-03-26.txt:23:19:36: <SevenInchBread> eh... I'll continue Sprout another day. I want to do like a "structured self-modification". Where you can give bits of the parse tree a label and then say "replace everything at x with SomeCode"
2007-03-26.txt:23:42:24: <oerjan> The files are oerjan.nvg.org/esoteric/Dupdog.hs and oerjan.nvg.org/esoteric/FingerTree.hs (third party module)
2007-03-27.txt:16:16:13: <Figs> you'd have to set up the entire program in a tree
2007-03-28.txt:18:17:49: <Figs> Tree = a < ((b<(d<i+j+k))+e);
2007-03-28.txt:18:19:26: <Figs> print(Tree);
2007-03-28.txt:18:20:34: <Figs> Tree = a < (((b<(d<i+j+k))+e)+(c<f+g+h));
2007-03-28.txt:18:21:43: <ais523> you should have redefined the whole nature of trees just so you could get away with using < and >
2007-03-28.txt:18:22:40: <Figs> Tree = a < (((b<(d<i+j+k))+e)+(c<f+g+h)); //Working C++ :D
2007-03-28.txt:18:25:44: <lament> Figs: not sure what kind of "actual project" needs hardcoded definition of trees.
2007-03-28.txt:18:26:35: <ais523> (the tree you wrote above in HOMESPRING notation)
2007-03-28.txt:18:26:58: <Figs> and interprets the tokens and reassembles a sequence (tree structure) by parsing it
2007-03-28.txt:18:29:07: * Figs can think of some weird uses for tree-manip. functions
2007-03-28.txt:18:29:34: <Figs> functions that clone trees and graft the clones on as new branches...
2007-03-28.txt:18:31:41: <ais523> some languages are better for trees than others
2007-03-28.txt:18:31:54: <ais523> the tree is the easiest data structure to understand in both Unlambda and Underload
2007-03-28.txt:18:32:18: <Figs> I think the tree is most certainly one of the harder to understand ds's when you try to use it in C++
2007-03-28.txt:18:33:26: <lament> a tree is almost the same as a linked list
2007-03-28.txt:18:35:13: * oerjan is reading the logs, and doesn't understand why Figs said bruteforcing the 4444 problem by setting up trees is hard.  Figs must not know Haskell.  :)
2007-03-30.txt:00:51:25: <oklopol> you don't know lazy. it took ½ an hour for me to leave for the shop across the street because i was too lazy to put on shoes
2007-04-01.txt:04:34:59: <CakeProphet> You can't say "hey this is a tree" or "hey this is a table"... without forcing every program that reads it to do some parsing.
2007-04-01.txt:04:36:16: <Figs> have you guys tried writing a general purpose tree?
2007-04-01.txt:04:36:57: <Figs> like, a C++ style library for tree structures like vectors, lists, maps, etc
2007-04-01.txt:04:37:32: <CakeProphet> well.... Lisp is pretty well-suited for trees... it uses linked lists internally.
2007-04-01.txt:04:38:00: <CakeProphet> or you could get all hyper-OO and make a tree object... if you're bat-fucking insane.
2007-04-01.txt:05:54:04: <CakeProphet> http://deadbeefbabe.org/paste/4188  <-- a very simple Tree like structure in Python
2007-04-01.txt:05:56:04: <Figs> class Tree(list):
2007-04-01.txt:05:56:12: <Figs> I assume you're declaring the clas Tree
2007-04-02.txt:01:49:02: <CakeProphet> except this one uses a decision tree to find the shorted possible way to do it.
2007-04-02.txt:22:43:50: <CakeProphet_> the whole "everything is an object" notion is infinitely recursive... you have objects consisting of objects.... the tree needs leaves at some point.
2007-04-08.txt:02:45:46: <CakeProphet> hehehehe... it's like a tree
2007-04-09.txt:00:20:19: <ihope> Having processes arranged in trees is... well, what's the reason behind that?
2007-04-09.txt:00:28:40: <ihope> So is there really any reason to put services in a tree like that/
2007-04-09.txt:03:25:59: <Pikhq> I'm using buildroot to create the initial root tree. . .
2007-04-10.txt:01:28:11: <Sukoshi> I would hope so, because you can make a tree based on parameters.
2007-04-10.txt:01:49:26: <bsmntbombdood> I suppose an ordered binary tree would work
2007-04-10.txt:01:55:30: <oerjan> making the tree balanced immediately.
2007-04-10.txt:01:58:42: <oerjan> recursively: make 2^n-1 first elements into one subtree, then read middle, then 2^n-1 next into another, then put together.
2007-04-10.txt:23:19:18: <Sukoshi> bsmntbombdood: Classes are just structs with type information. Generic methods are determined and then less-specific behavior is inlined if the function is ``continues'', and these are all kept either in a virtual method table or a tree that matches based on parameter.
2007-04-11.txt:00:48:46: <Sukoshi> Methods can *only* be executed linearly up the specific tree. No cast-avoiding.
2007-04-11.txt:01:51:42: <GregorR> I always forget which term is used to mean it falls lower on the tree :P
2007-04-17.txt:02:06:19: <SevenInchBread> will usually be close together in a directory tree.... usually. I have no empircal evidence to back that up.
2007-04-22.txt:00:47:15: <oerjan> http://oerjan.nvg.org/esoteric/Dupdog.hs + FingerTree.hs.  You can in theory use it if you can put the right functions together... 
2007-04-22.txt:00:54:45: <oerjan> by using the FingerTree module which implements lazily concatenated sequences
2007-04-22.txt:00:59:50: <oerjan> i suppose you could do such a structure with some simpler kind of tree, you need duplication, push and pop at both ends
2007-04-22.txt:01:14:04: <SevenInchBread> oerjan,  hmm... reverse lookup is hard to handle with tree concatenation
2007-04-22.txt:01:16:33: <SevenInchBread> >.> but with a tree you need to recurse the entire tree to get the very last character
2007-04-22.txt:01:17:14: <oerjan> you must recurse in any case unless you use the very clever FingerTree stuff
2007-04-22.txt:01:17:42: <oerjan> i believe that works by rebalancing the tree so the ends are always shallow
2007-04-22.txt:01:19:01: <oerjan> which is the same as for lookup in a naive tree
2007-04-22.txt:01:31:08: <SevenInchBread> oerjan,  I think the main rationale for using trees in memory.
2007-04-22.txt:01:32:39: <SevenInchBread> without using trees at all
2007-04-22.txt:02:31:21: <oerjan> essentially i think the tree will creep back in
2007-04-22.txt:02:40:56: <oerjan> yes, you want to save indexes instead of trees.
2007-04-28.txt:06:13:03: <oerjan> Haskell uses finger trees.
2007-05-15.txt:15:58:50: <oerjan> interesting that irc has so many netsplits because it is tree structured without cycles, and somehow they cannot fix that fundamental flaw
2007-05-15.txt:16:04:08: <SimonRC> routing in a non-tree is a PITA
2007-05-18.txt:02:43:20: <SimonRC> then, you mutate the program by fiddling with the tree
2007-05-18.txt:02:44:51: <SimonRC> Also, tree-surgery makes for a good way to mate programs together.
2007-05-18.txt:02:46:08: <SimonRC> The main one being that the explicit tree structures help you avoid syntax errors.
2007-05-18.txt:08:44:25: <GregorR> My attempt with something more similar to SimonRC's suggested tree isn't going well :P
2007-05-27.txt:03:17:40: <SimonRC> pointer-free trees might not be to bad...
2007-05-27.txt:03:18:40: <SimonRC> tree =  [A=label][B=left subtree][C=right subtree][length of ABC]
2007-05-27.txt:03:19:59: <SimonRC> an empty tree would have a special label field.
2007-05-27.txt:03:20:42: <SimonRC> i.e. look at the right subtree
2007-05-27.txt:03:26:43: <bsmntbombdood> it makes more sense to have length at the begining for a tree
2007-05-27.txt:03:28:54: <bsmntbombdood> you can't put anything in the right subtree untill you find how long the left one is
2007-05-27.txt:03:31:37: <bsmntbombdood> ...and so on in the right subtree
2007-05-29.txt:22:19:42: <oklopol> if you have a way to make bnf'ish regexes, basically tree-rewriting
2007-05-31.txt:05:43:01: <bsmntbombdood> hmm, by representing strings as trees you get constant time concatenation and O(log n) time indexing
2007-06-01.txt:02:34:49: <oerjan> <bsmntbombdood> hmm, by representing strings as trees you get constant time concatenation and O(log n) time indexing
2007-06-01.txt:02:35:32: <Pikhq> But by representing strings as *arrays* of trees of lists, you get to be *really* confusing!
2007-06-01.txt:04:37:08: <oerjan> the paradox being that most people say they wouldn't participate for any price, yet most take greater risks every day just by crossing the street
2007-06-01.txt:04:37:44: <bsmntbombdood> you could die by crossing the street
2007-06-04.txt:17:57:51: * CakeProphet pauses as he traverses his decision tree.
2007-06-04.txt:17:58:00: <lament> tree? more like a bush!
2007-06-04.txt:18:07:36: <CakeProphet> my decision tree does not account for sarcasm
2007-06-04.txt:18:33:34: <CakeProphet> MY DECISION TREE... PREDICTED THIS.
[too many lines; stopping]