Destructive form of "cons" - efficiently prepending an item to a procedure's argument which is a list

I don't think this can work with a procedure, you need something that does not evaluate the arguments, e.g. defmacro.

You may have a look at the article "How to pass a variable by name to a SKILL function?"

https://support.cadence.com/apex/ArticleAttachmentPortal?id=a1Od0000000naCvEAI&pageName=ArticleContent

Another option could be to wrap the list or whatever other variable in a disembodied property list and pass that to the function, e.g.

procedure( attempt_to_prepend_list(arg elem)
	arg->a = cons(elem arg->a)
)

arg = ncons(nil)
arg->a = list(1 2 3)
arg
==> (nil a (1 2 3))

attempt_to_prepend_list(arg 5)

arg
==> (nil a (5 1 2 3))

Or also pass the name of the property:

procedure( attempt_to_prepend_list(arg name elem)
	putprop(arg cons(elem get(arg name)) name)
)

attempt_to_prepend_list(arg 'a 5)

Passing a table to the function would also work and might be faster with many entries than the list.

Regards,

I didn't see the original post (for some reason, I didn't get any email notification; I've asked our IT to investigate why as this has happened a couple of times recently).

Without having read the original post, I came up with a solution the same as JustinSilver 's proposed solution. The fundamental issue is that variables in SKILL are pointers - and if a variable is pointing at a list, it's pointing at the list cell that is the car of the list. That means that you can change the contents of that list cell (rplaca) or the next item in the list (rplacd) whilst the pointer keeps pointing at the same list cell. If you need to add a new value to the beginning of the list, the only way to do that is to update the pointer that the variable holds, which can't be done. Macros could achieve this, but only for the single variable you are updating - in essence you would generate the expression to reassign the variable to the list with the newly consed value on the front. 

You could also always pass around a list with an additional dummy value on the front, and insert the new value between the first value and the rest of the list (similar to henker 's DPL-based solution, without the DPL.

The reason why there's not a built-in function to do this is:

1. Your workaround code won't work universally - for example, it relies on the list being non-nil (there is no way to make it work with an empty list; this is the key reason why disembodied property lists have a dummy value, typically nil, at the beginning - as that way the list can always be destructively modified).
2. There's no efficiency benefit as there is with tconc; in this case it's actually less efficient than using cons (cons is very efficient as it is). In general, destructive list functions are few and far between, and only used when there's a clear performance benefit in doing so (or to implement some special structure such as a disembodied list)

In a functional language, it would be more usual to return the updated list rather than relying on a side-effect of changing the list in place; if you really want that I'd go for the dummy value at the beginning approach that I mentioned earlier because that would then work if the real list contents are nil or any number of elements (similar to how DPLs work).

Andrew

All great points. Thanks for the very thorough explanation.

My particular use case for this was to parse a cellview and iteratively pre-append to a list based on the number of instances, nets, etc. Initially I thought I would need to wrap these lists in another list (since I can only return a single variable) and I wanted to avoid that. However, it looks like DPL can do this cleanly.

In the end though, I ended up using the tconc approach (passing tconc structures as parameters) since the choice of appending vs. pre-appending wasn't such a big deal for me.

-Justin

Justin,

Note you can always have your function return multiple things as a list:

list(retVal1 retVal2 retVal3)

and then in the calling function do:

destructuringBind((myVar1 myVar2 myVar3) yourFunctionWithThreeRetValues()
  ; do something with myVar1 myVar2 myVar3
)

Andrew