Does it make sense to talk about the concatenation of infinite series? Does a series of numbers defined as the concatenation of two or more infinite series, for example all the positive integers followed by all the negative integers, make mathematical sense?
I came up with this problem while writing an implementation of infinite series in Erlang. I'm not sure how to represent this in code in a way that isn't horrific, and wondered if it even made any sense. I'm a programmer, not a mathematician, so won't understand any answers too steeped in technical terms!
EDIT: Ok, After reading and being confused by a few answers I have discovered that the mathematical definition of concatenation appears to be a bit different to my understanding of it from programming.
When I say "the concatenation of two infinite series", what I actually mean is a new series that consists of all the elements of the first series followed by all the elements of the second series.
So for the example I gave above, the positive integers followed by the negative integers, you could start at the beginning of the series and get only positive numbers, never in fact reaching the second infinite series.
However, if you then applied some sort of 'filter' to this concatenated (in my definition) infinite series, that would somehow make the first part of it finite, then it would be possible to count up to elements of the second series. 
I hope this makes more sense now, and if there is a more appropriate mathematical term I can use instead of concatenation, please let me know. Ta!
 A: The answer is, it depends ;-).
It certainly does make sense to talk about the concatenation of two infinite series. If you view an infinite series as a function $f \,:\, \mathbb{N} \to A$ which assigns to each number one element of $A$, then you can view the concatenation of two such series $f_1$, $f_2$ as function $g \,:\, \{1,2\}\times\mathbb{N} \to A$, where $g(1,n) = f_1(n)$ and $g(2,n) = f_2(n)$.
The resulting $g$, however, isn't an infinite series itself, since it doesn't map integers to elements of $A$, but rather pairs of integers.
If you want the result of such a concatenation to be an infinite series itself, you'll have to use a more general definition of what constitutes an infinite series. A way to do that is to use ordinal numbers (http://en.wikipedia.org/wiki/Ordinal_number). Using that, you could define an infinite series of length $\alpha$ to be a mapping $$
  s \,:\, \{\beta \,:\, \text{$\beta$ is an ordinal and }\beta < \alpha\} \to A \text{.}
$$
The original definition of an infinite series would then conincide with this definition if you pick the length $\omega$, i.e. the smallest ordinal larger than all finite ordinals. For $g$, i.e. two concatenation of two series with length $\omega$, you'd have to pick $\alpha = \omega + \omega$. In other words, those would have length $\omega + \omega$.
Ordinals are often constructed in a way that defines an ordinal $\alpha$ to simply be the (set-theoretic) union of all smaller ordinals. That allows you to simplify the definition of a series of length $\alpha$ to just $$
  s \,:\, \alpha \to A \text{.}
$$
You'll have to decide how far (in terms of ordinal sizes) you want to be able to take this. If you only allow finitely many concatenation steps of series of length $\omega$, then all the ordinals you'll encounter will be smaller than $\omega\cdot\omega$. If you allow $\omega$-many concatenations of series of length $\omega$, one such step reaches $\omega\cdot\omega = \omega^2$, the next one $\omega^3$ and so on. After $\omega$-many such steps you reach $\omega^\omega$. A natural limit may thus be the ordinal $\epsilon_0$ (http://en.wikipedia.org/wiki/%CE%95%E2%82%80), which cannot be expressed as a cantor normal form (http://en.wikipedia.org/wiki/Ordinal_arithmetic#Cantor_normal_form) of smaller ordinals. By limiting yourself to ordinals smaller than that, you're assures that any ordinals you encounter than be written as the sum of finitely many powers of $\omega$, where the exponents obey the same restriction. It should be possible to represent such ordinals quite efficiently in a program, though I've never tried. But something tells me there's a ton on literature on that...
