Write a program, given an input n, will generate all possible n-tuples using natural numbers.

n=1
(1),(2),(3),(4),(5),(6)...

n=2
(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3)...

n=6
(1,1,1,1,1,1) (1,1,1,1,2,1) (1,1,1,2,1,1)... 

• The output may be in any order that does not break any other rules.


• The program must be written to run forever and list all applicable tuples exactly once, in theory.
  
  
  • In reality, your program will reach your integer type's limit and crash. This is acceptable as long the program would run infinitely long if only your integer type was unlimited.
  
  
  • Each valid tuple must be listed within finite time, if only the program were allowed to run that long.
  
  


• The output may, at your option, include zeroes in addition to the natural numbers.


• You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)


• Code-golf rules apply, shortest program wins.

Thanks to "Artemis Fowl" for feedback during the sandbox phase.

Haskell, 62 bytes

([1..]>>=).(!)
0!s=[[]|s<1]
n!s=[a:p|a<-[1..s],p<-(n-1)!(s-a)]

Try it online!

n!s generates all the n-tuples that sum to s.

Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].

This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).

Perl 6, 37 bytes

$++.polymod(1+$++ xx $_-1).say xx *

Try it online!

Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...

VDM-SL, 51 bytes

g(i)==if i=0thenelsex:nat,y in set g(i-1)

Recursive set comprehension with sequence concatenation..

Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):

functions 
g:nat->set of ?
g(i)==if i=0thenelsex:nat,y in set g(i-1)

Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1

05AB1E, 15 bytes

<[>DÅœIùvyœÙvy,

Inspired by @Lynn's Haskell answer.

Try it online.

Explanation:

< # Decrease the (implicit) input-integer by 1
 [ # Start an infinite loop:
 > # Increase the integer at the top of the stack by 1
 D # And duplicate it (for the next iteration)
 Ŝ # Create lists of national integers that sum to this integer
 Iù # Only leave the lists of a size equal to the input
 v # Loop over each list `y` in this list of lists:
 yœÙ # Get all possible unique permutations of this list `y`
 v # Inner loop over each list `y` in this list of unique permutation lists:
 y, # And output this list `y` with a trailing newline