Code Golf
Mathgeek
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 C (gcc)
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 APL (Dyalog Unicode)
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 Erlang (escript)
petStorm
# [Erlang (escript)], 29 bytes
As a special bonus this also works for strings.

```erlang
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
```erlang
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 W
petStorm
## [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.
```

Enter question or answer id or url (and optionally further answer ids/urls from the same question) from

Separate each id/url with a space. No need to list your own answers; they will be imported automatically.