Converting code to shadow for editing?

[VectorZeroAI]

Hello.

I wanted to suggest this feature that I would find quite usefull:
Converting existing code files to Shadow files of pseudocode for redactability purposes.

I, and many other developers, have to redact and refactor a lot,and with a feature to convert a codebase to a shadow code base, it would be really good.

I would also like to see a way to configure how the pseudocode is represented by the model when converting from actual code to shadow code, kinda in like a style guide instruction, or via example based In Context Learning.

Hope this can someday be in the functionality.

[VectorZeroAI]

Opps.
Also, sorry for that, but am I stupid or why can I not figure out how to label this?

[adifyr]

That's a very interesting feature! I'll definitely look into this.

[adifyr]

@VectorZeroAI Hi. I am going to have a go at this feature. Can you give me an example of what kind of "Shadow Code" you want as output? Something along the following lines:

Real Code As Input:

async function doSomething(someParameters: string[]) {
  // Your original code here.
}

Output Shadow Code:

// What would your ideal shadow code look like?

[VectorZeroAI]

async function SomeName (
	param name: all constrais in plaintext
	)
	// some more readable repr of what the code does,
	// but not excluding any steps
	// close to the code but also compacter due to not following strict syntax

But for a more concrete example, with a code body, here is anouther example of how I see this:
(Sorry, my main lang is python, so this example is python)

def str_to_num(str_in: str) -> float|int|None:
	try:
		return int(str_in)
	except Exeption:
		pass
	
	try: 
		return float(str_in)
	except Exception:
		pass
	# TODO: refactor
	return None

as this shadow code:

function str_to_num(
	str_in: string
	) returns float or int or None:

	try:
		return int(str_in)

	else try:
		return float(str_in)
	#Comment: "TODO: refactor"

	else:
		return None

Kinda like this. Function signatures can be single line or multi line, depending on the amount of input params.
But it would be great if style of pseudocode was configurable or auto learned. (Use user written pseudo code and its corresponding real code as examples for generated pseudo code, but thats not really nesesery. Or user written guidelines in a config file. But those are just suggestions, not really nesesary.)

[adifyr]

@VectorZeroAI Thank you for the comprehensive example.

You mentioned redacting code as a requirement as well. Can I have an example of that too?

[VectorZeroAI]

Yeah, sure. @adifyr . But example is python, hope you dont mind that.
So lets say we have this file:

def fibonacci(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

if __name__ == "__main__":
    for num in fibonacci(10):
        print(num)

And we want to redact it via shadow code.
We convert it to a shadow code like this:

function fibonacci(
    n: int
)
    a = 1
    b = 0
    repeat n times:
        yield a
        a = b
        b = a + b

if file is main executable:
    for each of fibonacci(10):
        print(each)

Lets say we now want that file to execute that function even if its not the main executable file.
We remove the guard in the shadow code:

function fibonacci(
    n: int
)
    a = 1
    b = 0
    repeat n times:
        yield a
        a = b
        b = a + b

for each of fibonacci(10):
    print(each)

And convert it back to real code.
In this example, it will be simpler to do that edit directly on real code, but if its more complex then that, then that would make far more sense to change shadow code, and convert back, insdead of redacting the code directly. For lets say large logic refactors.

The example doesnt really explain what I mean, but I think you get the idea.

I would also suggest implementing with diffs, like diff that changed in shadow code, and only make the model regenrate the changed parts. Or something like that.