Question

In C, you can have a pointer to the first and last element of a singly-linked list, providing constant time access to the end of a list. Thus, appending one list to another can be done in constant time.

As far as I am aware, scheme does not provide this functionality (namely constant access to the end of a list) by default. To be clear, I am not looking for “pointer” functionality. I understand that is non-idiomatic in scheme and (as I suppose) unnecessary.

Could someone either 1) demonstrate the ability to provide a way to append two lists in constant time or 2) assure me that this is already available by default in scheme or racket (e.g., tell me that append is in fact a constant operation if I am wrong to think otherwise)?

EDIT:
I should make myself clearer. I am trying to create an inspectable queue. I want to have a list that I can 1) push onto the front in constant time, 2) pop off the back in constant time, and 3) iterate over using Racket’s foldr or something similar (a Lisp right fold).

Answer 1

Standard Lisp lists cannot be appended to in constant time.

However, if you make your own list type, you can do it. Basically, you can use a record type (or just a cons cell)—let’s call this the “header”—that holds pointers to the head and tail of the list, and update it each time someone adds to the list.

However, be aware that if you do that, lists are no longer structurally inductive. i.e., a longer list isn’t simply an extension of a shorter list, because of the extra “header” involved. Thus, you lose a great part of the simplicity of Lisp algorithms which involve recursing into the cdr of a list at each iteration.

In other words, the lack of easy appending is a tradeoff to enable recursive algorithms to be written much more easily. Most functional programmers will agree that this is the right tradeoff, since appending in a pure-functional sense means that you have to copy every cell in all but the last list—so it’s no longer O(1), anyway.

---

ETA to reflect OP’s edit

You can create a queue, but with the opposite behaviour: you add elements to the back, and retrieve elements in the front. If you are willing to work with that, such a data structure is easy to implement in Scheme. (And yes, it’s easy to append two such queues in constant time.)

Racket also has a similar queue data structure, but it uses a record type instead of cons cells, because Racket cons cells are immutable. You can convert your queue to a list using queue->list (at O(n) complexity) for times when you need to fold.