or
Mathgeek
array-manipulation source-rules
Nearly every language has a built-in that allows people to reorder lists at will. But that's no fun! Let's revamp that!

Without using any functions that modify a variable (non-fixed) amount of elements in a list (so no arbitrary sort or order or reverse functions, etc), reverse the order of the not-necessarily-sorted elements.

Input and output are in any reasonable format, though they must be identical formatting, language permitting.

Examples:

| Input | Output |
|-------|--------|
|`[a b c]`|`[c b a]`|
|`[1 2 3 4]`|`[4 3 2 1]`|
|`[]`|`[]`|
|`[G]`|`[G]`|
|`[R R]`|`[R R]`|
|`[[1 2] [3 4]]`|`[[3 4] [1 2]]`|

Examples of permitted built-in functions;

* Swap two or more target elements
* Functions that reverse or re-arrange a fixed list (non-var)0
* Comparison functions
* List-splitting functions that split at designated index (SPLITAT[5])

Examples of non-permitted built-in functions
* List randomization
* List sorting
* List reversing
* List-splitting functions that split at every n-th index (SPLITEACH[5])
Top Answer
S.S. Anne
# [C (gcc)], 56 bytes

    f(a,l,p,t)int*a,*p;{for(p=a+l;p>=a;*a++=t)t=*--p,*p=*a;}

Temporary swap. XOR-swap won't work here, and even if it did it would be longer.

[Try it online!][TIO-k83jtu6d]

[C (gcc)]: https://gcc.gnu.org/
[TIO-k83jtu6d]: https://tio.run/##RY7BDoIwDIbvPEVDYsK2EkHUy5wvghyWAYYExzKJBwnPjt0O2Mv/t/3a/CZ/GrNtfaZxRIczG@zMNXInl37ymVNajNLdlZZcC6FmNiue544AxbVcN8LhpQebfaahZcmSAFUYau/rBhQsUCJUCCeEC8IV4UxSlbDKHR07S@B7@HYT5fCeHf@@Lhomk4jGHgO9TyhheGDovJAkt7AlIwSLQCjnCemz9NA@bIoxlwk/1@0H "C (gcc) – Try It Online"
Answer #2
Adám
# [APL (Dyalog Unicode)], 14 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))

Anonymous prefix lambda.

```apl
{0::⍵⋄⊃,⍨/⊂¨⍵}
```

[Try it online!][TIO-k88mwsgr]

`{`…`}` "dfn"; argument is `⍵`:

 `0::⍵` if any error happens, return the argument as-is

 `⋄` try:

  `⊂¨⍵` enclose each element of the argument

  `⊃`…`/` insert the following function between elements:

   `,⍨` swapped concatenation

[APL (Dyalog Unicode)]: https://www.dyalog.com/
[TIO-k88mwsgr]: https://tio.run/##SyzI0U2pTMzJT///v9rAyupR79ZH3S2Pupp1HvWu0H/U1XRoBVCo9n/ao7YJj3r7gBKPetc86t1yaL3xo7aJj/qmBgc5A8kQD8/g/2kK6olJyepcaQqGCkYKxgomQBZQNZBUdweJqgcFgSgNoKymBlBaEwA "APL (Dyalog Unicode) – Try It Online"
Answer #3
A-ee
# [Erlang (escript)], 29 bytes
As a special bonus this also works for strings.

    r([H|T])->r(T)++[H];r(_)->[].

[Try it online!][TIO-k7rl120g]

[Erlang (escript)]: http://erlang.org/doc/man/escript.html
[TIO-k7rl120g]: https://tio.run/##bY3NCoMwEITvPsVcCgluhP6c2uLZB/AgLKFYCRJotayWXnz31FqwFDKn/eZbGCe3umuNGxrxjzEkQRQXU2m1yUWVOk25sCdRl5nZZmGD0g0jhqcfXXKvfafYapg8wRzfH18yC7XQJyyq0pimtahwNuAV13BNuBIaSxG3JewIe8IhqqNlG22FIFGxbFgCLyv2/@OH30tn4Q0
# Explanation
```
r(     )    % This reverse function
  [H|T]     % Tries to split the input list into
            % A head and a tail.
      ++[H];% Put the head at the end of the list
->r(T)      % And continue reversing the list.
      
r(_)->      % If it's un-splittable,
[].         % Return the empty list.
```
Answer #4
A-ee
## [W](https://github.com/A-ee/w), 4 bytes
+2 bytes due to fixing a bug in nested lists.
```
}M+r
```
## Explanation
```
}M   % Wrap all items in input in brackets
  +r % Join all lists
     % Note that this isn't a built-in,
     % it works because the implicit inputs
     % for +r are provided in reverse.
```
Reversing a List
Adám
@Mathgeek Suggested test case: `[[1 2] [3 4]]`
Adám
@Mathgeek I've tagged this challenge for you, but please do so yourself in the future.
A-ee
YES!!! IT'S OPEN!
A-ee
(What do you mean by "(non-var)" ?)
A-ee
The question would sound a lot more interesting if it says "But that's no fun! Let's reverse that!"
A-ee
Is it anything more you can add? Like, making it a restricted source challenge?
A-ee
You can do a reduce that joins the accumulator & current item after swapping them. [Try it online!](https://tio.run/##Sy3KScxL100tTi7KLCj5z/W/KLUstag4VSM6VlMBDHTtFKJjrbng4h4KNQohQEmgOEwsRFNBW1sh2iNW739uYmYeQi9Ee2a@VXlRZkmqBtwMQx0FIx0F41hNTb3/AA)
A-ee
I was tempted to answer. BUT I  realized that this question isn't open yet.
xnor
Maybe I'm interpreting "modify" more literally than you intend, but I don't know how one would define it in general.
xnor
In this case, the restrictions seem to targeted at languages that modify list elements in place, and I'm not clear how one would interpret them for functional languages (does anything go?), or even for imperative languages when new lists are defined. 
xnor
Unfortunately, I think challenges like this are bound to get tangled up in ambiguities and disagreements, even with a valiant effort to explain what's allowed and not. The only way to make it rigorous is really to define your own sub-language.
Mathgeek
Of course you can do other things to the list, like pop/push values or determine its length or iterate through it, as long as the built-ins that *modify the array itself* cannot do so variably.