Tips for storage in a golfing language I am writing a golfing language. 

Do you suggest variables, stack(s), tapes, registers, etc for storage in a code-golf language? What about implicit input?

Rough definitions:


A variable is simply a name (usually one character long in golfing languages) that a value can be assigned to, and later retrieved by that name.
A register is like a variable, but it has its own (usually single-byte) commands for setting/getting the value.
A stack is a variable-length array/list of values, where the most recently added values (the values "on top") are the ones that are being modified.
A queue is like a stack, except the values "on the bottom" are the ones that are being modified.
A tape is a static array/list of values where each value has an index. The main difference between a stack and a tape is that values on a tape are modified in-place.


I would appreciate to know the advantages and disadvantages of each option for different scenarios, and overall. Please avoid opinions, and backup statements with reasoning.
I suggest all of them!

More seriously, they all come in handy some of the time, and the more the better! Implicit input is never bad, just have a flag to turn it off. Variables are helpful so they don't need to be found on a stack or tape; same with registers. Stacks are helpful to store data, and so are tapes. I recommend trying to implement multiple, say a stack and registers, or a stack and variables, like GolfScript. If you can make each function one byte, then your language will probably be effective at golfing, as you can use the advantages of each. 

An example:


Say I want to take two numbers as inputs, and add their string lengths
Variables might be better for this (a stack might not)
Example code in GolfScript (with implicit input):

~,\,+
~ # Eval input (e.g. "1 2" &gt; 1, 2)
, # Take Length
\ # Reverse items on the stack
, # Take Length
+ # Add
  # Implicit output


However, with variables (I know it's longer, it just doesn't have to swap places on the stack):

~,:a;,:b;ab+
~ # Eval input
, # Get length
:a# Store in "a"
; # Discard value left on stack
, # Length
:b# Store in "b"
; # Discard
a # Recall a
b # Recall b
+ # Add
  # Implicit output



Overloads

Another thing that can be helpful is overloads. For example, if you have a variable storing function, maybe it could be used as a monad (one-input function; I'm not sure of the term out side of J/K/APL) to add to the stack or tape. 

Example:

c12 # Stores "1" into register 2
c1] # Pushes "1" onto the stack ("]" is used to denote the end of the monad)