ENB: Ahas re paste-retaining-clones
Edward K. Ream
Today is my 74th birthday. This Engineering Notebook post is my birthday present to myself.
For the last week, I have been trying to make paste-retaining-clones work. Unit tests show this command improperly computes v.parents arrays in the pasted outline.
This morning I saw the way forward:
Aha! paste-retaining-clones must recompute all v.parents arrays in the entire outline!
I won't attempt a formal proof, but I am sure this Aha is correct. Note that the paste-node command does not require the complications described next.
Recomputing v.parents
But how to recompute v.parents?
- We can't use VNode generators because they don't yield VNodes in outline order.
Aha! Define a c.all_vnode_positions generator. This hybrid generator will yield VNodes in the same order as p.all_positions using neither v.parents nor Positions.
Is it possible to write this generator? Yes, it is. The generator will maintain an explicit stack just like Position.stack. Note: c.all_vnode_positions must yield the hidden root VNode.
Recomputing all v.parents
Supposing the new generator exists, recomputing all v.parents arrays is straightforward. Something like this (untested):
for v in c.all_vnode_positions():
v.parents = []
for v in c.all_vnode_positions():
for child in v.children:
child.parents.append(v)
Yes, a one-pass solution is possible. It might be faster.
Summary
Aha! The paste-retaining-clones command must recompute all v.parents ivars. This recomputation is sound. The link correction in c.checkVnodeLinks is not.
Leo can use neither Position nor VNode generators to do the recomputation.
Aha! A new generator, c.all_vnode_positions, will yield all VNodes in outline order using neither v.parents nor Positions.
Given this generator, updating all v.parents ivars will be straightforward.
Edward
P.S. Let us define a hybrid generator as a generator yielding VNodes in the same order as some Position generator without using Positions.
Could Leo replace Position generators with hybrids? I think not. For example, please take a look qtree.full_redraw. It would not be fun to eliminate Positions there.
In any event, Leo's Position class is never going away :-)
EKR
jkn
Edward K. Ream
Well, Happy Birthday Edward! ;-)
Edward K. Ream
> Is it possible to write [c.all_vnode_positions]?
You bet:
def all_vnode_positions(self) -> Generator:
c = self
to_be_visited: list[VNode] = [c.hiddenRootNode]
while to_be_visited:
v = to_be_visited.pop()
yield v
for child in reversed(v.children):
to_be_visited.append(child)
This generator passes the following consistency test:
vnodes1 = [c.hiddenRootNode] + [z.v for z in c.all_positions()]
vnodes2 = list(c.all_vnode_positions())
assert vnodes1 == vnodes2
Edward
David Szent-Györgyi
Today is my 74th birthday. This Engineering Notebook post is my birthday present to myself.
Edward K. Ream
>> Is it possible to write [c.all_vnode_positions]?
> You bet: [snip]
> This generator passes the following consistency test:
vnodes1 = [c.hiddenRootNode] + [z.v for z in c.all_positions()]
vnodes2 = list(c.all_vnode_positions())
assert vnodes1 == vnodes2
The elegance of this VNode-based stand-in for c.all_positions raises some follow-on questions.
Does c.all_positions use v.parents?
Apparently not, which means that c.all_vnode_positions isn't strictly necessary. Leo could define it like this:
def all_vnode_positions(self):
c = self
yield c.hiddenRootNode
for p in c.all_positions():
yield p.v
But this definition would be much worse than a VNode-based definition.
c.alt_all_positions
Could Leo define a generator, say c.alt_all_positions, using c.all_vnode_positions as a template? Yes it could.
In my original post, I said, "[c.all_vnode_positions] will maintain an explicit stack just like Position.stack." In fact, the generator uses only a stack of VNodes. But c.alt_all_positions must indeed use a stack just like Position.stack.
c.all_positions calls p.moveToThreadNext to advance through the outline. In turn, p.moveToThreadNext calls p.moveToParent, p.moveToFirstChild and p.moveToNext.
c.alt_all_positions will use none of these helpers. Instead, the new generator will operate directly on its explicit stack, yielding new positions with (copies of) the explicit stack. There will be no need for a "copy" kwarg.
Summary
c.alt_all_positions is feasible. Similarly, Leo could define other "alt" generators.
Alt generators should be faster (and use less memory) than the corresponding legacy generators.
Nevertheless, Positions themselves and all Position methods must remain, whatever their internal form.
Edward
Edward K. Ream
Thomas Passin
Edward K. Ream
Best wishes on your birthday from this quarter, too!
Félix
Another year older, but your programming prowess keeps getting younger!
Cheers to you and the adventures your code will take us on! 🚀
Edward K. Ream
Edward, I also want to join my voice to the group in wishing you a happy birthday! :DSo Happy Birthday, Edward!
Another year older, but your programming prowess keeps getting younger!
Cheers to you and the adventures your code will take us on! 🚀
Viktor Ransmayr
Edward, I also want to join my voice to the group in wishing you a happy birthday! :D
Edward K. Ream
"""An alternative implementation of c.all_positions."""
c = self
PositionStack = list[tuple[VNode, int]]
def visit(childIndex: int, v: VNode, stack: PositionStack) -> Generator:
yield leoNodes.Position(v, childIndex, stack[:])
stack.append((v, childIndex))
for child_childIndex, child_v, in enumerate(v.children):
yield from visit(child_childIndex, child_v, stack)
stack.pop()
stack: PositionStack = []
for i, v in enumerate(c.hiddenRootNode.children):
yield from visit(i, v, stack)
c = self.c
self.clean_tree()
cc = self.create_test_paste_outline()
assert cc.h == 'cc', repr(cc)
positions1 = list(c.all_positions())
positions2 = list(c.alt_all_positions())
assert positions1 == positions2
Edward K. Ream
Another one joining late - but - still in time ;-)
Enjoy your birthday exactly the way you prefer to !
HaveF HaveF
I'm a person who is not good at expression, but I hired GPT4 to express my meaning.
With a soul for scripting and heart born for nodes,In the universe of codes, there emerged a hero,
Edward K. Ream, a commander of codes,
Your name will forever against the time flow.
A dance of digits, a cosmos of clones,
The LEO editor scribed in resounding tones.
Attributed trees, woven like intricate lace,
Guided by you, they've found their harmonious place.
On your 74th birthday, we forge this verse,
To acknowledge your work, in the universe diverse.
Beyond strings, beyond scripts, beyond plugins and pane,
In the rhythm of codes, you etched your name.
You gave us LEO, a tool so sublime,
An editor for eternity, transcending space and time.
A gift to all coders, a resonating rhyme,
In the heart of each node, your legend will chime.
As plugins merge with the scripts' gentle flow,
In each line and leaf, our respect for you will grow.
Your innovation, like constellations, in the night sky,
Illuminates our world, as the years go by.
So here's to you, Edward K. Ream,
To your wisdom, your vision, your tech-inspired dream.
In body pane of life, on this beautiful date,
We sing your praises, as we celebrate.
For the joy of coding, the ease of design,
For letting our digital dreams align,
We, the LEO editors, filled with gratitude sublime,
Salute you today, and for the infinite time.
Another one:
In the realm of the Leonine World, among the stellar nodes,A warrior named Ream stands tall, riding the binary codes.
As the clock strikes and ushers a new day,
We celebrate the birth of the sage, who showed us the way.
In the depths of the .leo files, lies the grand design,
Customizing, controlling, coloring each line.
Through the syntax, the scripts in Python dance,
Embracing directives, in an elegant prance.
Using Leo as a Personal Information Manager,
Creating Documents from Outlines that shimmer,
Leo and Emacs, Leo and Asciidoctor too,
In the universe of codes, each day something new.
The bridge of Leo, linking to IPython's shore,
Clicking through the links, opening every door.
Exploring Leo's code base, a mysterious maze,
In the Leonine way to refactor code, we gaze.
Plugins, like stars, embedded in the night,
Guiding us through the process with their radiant light.
Through the Vim and the WebSocket Server's tide,
In Leo’s Markup Language, we take pride.
As we continue our journey, on this command reference,
Navigating through the labyrinth of codes, in coherence.
Whether debugging with Leo, or writing plugins grand,
We remember our mentor's touch, his guiding hand.
So here’s to Edward K. Ream, a beacon, a guide,
Through the Leonine realm, for us you coincide.
In the chaos of codes, you brought order and rhyme,
And for that, we thank you, until the end of time.
This poem is for you, our gratitude to attest,
In the heart of every Leonine, your legacy will rest.
With each passing year, your brilliance only grows,
In the eternal flow of codes, your genius continuously flows.
I like them both :D
vitalije
Today is my 74th birthday. This Engineering Notebook post is my birthday present to myself.
- We can't use VNode generators because they don't yield VNodes in outline order.
yield v
for ch in v.children:
yield from v_generator(ch)
a = ('hidden-root-vnode-gnx',) + tuple(p.gnx for p in c.all_positions())
b = tuple(v.gnx for v in v_generator(c.hiddenRootNode))
assert a == b
# of coarse you can avoid yielding root vnode with
# a slightly different generator
def v_gen2(vs):
for ch in vs:
yield ch
yield from v_gen2(ch.children)
# and it can be used like this
a = tuple(p.gnx for p in c.all_positions())
b = tuple(v.gnx for v in v_gen2(c.hiddenRootNode.children))
assert a == b
g.es('ok')
vitalije
for ch in v.children:
yield ch
yield from v_gen2(ch)
Edward K. Ream
> I really don't know where did you get this idea from?
"""
Recompute all v.parents arrays using neither positions nor v.parents ivars.
"""
c = self
root_v = c.hiddenRootNode
# Clear all v.parents arrays.
root_v.parents = []
for v in c.alt_all_unique_nodes():
v.parents = []
# Loop invariant: Visit each *parent* vnode *once*.
# Child vnodes may be visited more than once.
for child in root_v.children:
child.parents.append(root_v)
for parent in c.alt_all_unique_nodes():
for child in parent.children:
child.parents.append(parent)
Edward K. Ream
"""
Yield all unique VNodes corresponding to c.all_positions.
This is an equivalent (much worse) generator:
for z in c.all_unique_positions():
yield z.v
"""
c = self
seen: dict[str, bool] = {}
to_be_visited: list[VNode] = list(reversed(c.hiddenRootNode.children))
while to_be_visited:
v = to_be_visited.pop()
seen[v.gnx] = True
yield v
for child in reversed(v.children):
to_be_visited.append(child)
Edward K. Ream
> I'm a person who is not good at expression, but I hired GPT4 to express my meaning.