Code Golf
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.


| Input | Output |
|`[a b c]`|`[c b a]`|
|`[1 2 3 4]`|`[4 3 2 1]`|
|`[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
# [MAWP], 6 bytes
[Try it!][mawp_interp]

0       Push 0 to stack
|       Push input to stack
[       Start of loop
;       Output top of stack as ASCII char
]       End of loop. Jump to its [ if top of stack isn't 0
.       Terminate program
Mawp doesn't support arrays, but, given a sequence of characters as input, reverses their order. May be incompeting.
Answer #2
# [Rust], 55 bytes

    |x:&mut[_]|for i in 0..x.len()/2{x.swap(i,x.len()-i-1)}

[Try it online!][TIO-kffszz0w]

If I were allowed to compile in release mode, I'd exploit undefined behaviour to shave off a byte (`+!i` instead of `-i-1`).

[TIO-kffszz0w]: "Rust – Try It Online"
Answer #3
# [Runic Enchantments], 18 bytes

    ;!$ '$]L

[Try it online!][TIO-kd11jh7e]

[Runic Enchantments]:
[TIO-kd11jh7e]: "Runic Enchantments – Try It Online"

Runic does not support arbitrary data structures (eg. lists or lists of lists) but it will happily read input (space separated) and spit it back out. As input is pushed to the stack and then dumped back out top to bottom (LIFO) this results in the input being reversed.
Answer #4 C (gcc)
S.S. Anne
# [C (gcc)], 56 bytes


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

[Try it online!][TIO-k83jtu6d]

[C (gcc)]:
[TIO-k83jtu6d]: "C (gcc) – Try It Online"
Answer #5 APL (Dyalog Unicode)
# [APL (Dyalog Unicode)], 14 [bytes]( "When can APL characters be counted as 1 byte each?") ([SBCS]( ".dyalog files using a single byte character set"))

Anonymous prefix lambda.


[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)]:
[TIO-k88mwsgr]: "APL (Dyalog Unicode) – Try It Online"
Answer #6 Erlang (escript)
# [Erlang (escript)], 29 bytes
As a special bonus this also works for strings.


[Try it online!][TIO-k7rl120g]

[Erlang (escript)]:
# 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 #7 W
## [W](, 4 bytes
+2 bytes due to fixing a bug in nested lists.
## 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.
Answer #8
# [Nim], 61 bytes

    proc r(a:var seq)=
     for i in 1..a.len div 2:swap a[i-1],a[^i]

[Try it online!][TIO-khp219s8]

[TIO-khp219s8]: "Nim – Try It Online"

A procedure that reverses a `seq` of any type in place.

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.