First-order mutual-recursive functions Turing-complete or incomplete?
Roughly speaking, as a heuristic, if your language includes primitives of unbounded size as well as standard control structures (e.g., loops and conditional statements), the language is likely to be Turing complete.  (Credits: I'm just expanding on Dmitry's observation.)  I'll show a few examples below.
If your language doesn't have loops, you can simulate them with recursion.
Linked lists
If your language includes linked lists, it will be Turing-complete.
In particular, you can encode a Turing machine with two linked lists.  You split the tape into two pieces, the part to the left of the head and the part to the right of the head.  Let $L$ be a linked list of the symbols on the tape to the left of the head, and $R$ the symbols to the right.  The linked list should start with the symbols closest to the head and go outward.
Now you can simulate each of the individual operations of the Turing machine using a few lines in your programming language.  For instance, shifting the tape head to the right can be done by popping an item $x$ from the front of $L$, then pushing $x$ onto the front of $R$.  The finite-state control works on finite data and so can be expressed as a finite number of simple operations.  Now put an infinite loop around this, with each iteration of the loop simulating one step of the Turing machine, and you have built an interpreter for a Turing machine in your language.
Bigints
If your language includes bigints (i.e., integers that can be of unbounded size) and basic operations on them (e.g., add, multiply, compare, divide), then it will be Turing-complete.
In particular, you can simulate linked lists of items over a fixed alphabet using bigints.  Suppose you want to encode a linked list of bits.  Then you can encode this as a bigint by treating the sequence of bits in the linked list as the binary representation of an integer (the least significant bit is the first bit in the linked list, and so on).  Basic operations on the linked list can then be translated into operations on the integer.  For instance, popping a bit from the head of a linked list can be expressed as $b := L \bmod 2, L := (L-b)/2$; pushing a bit can be expressed as $L := 2L+b$; and so on.  More generally, if you have a linked list where each item is in the range $\{0,1,\dots,k-1\}$ (e.g., a tape alphabet of size $k$), then this can be viewed as an integer in base $k$.  There are some details -- for finite lists, you probably want to have one reserved symbol to indicate the end of the list -- but they don't change the general picture.
Now you can use this to simulate linked lists, and then use the construction above to simulate a Turing machine.