Most programmers come from an imperative background. Something in the Algol family. Learning a scheme/lisp, a functional language like Haskell, a stack based on like Factor or any of the numerous other types of languages is only going to make you a better programmer.
Think type languages are awful? Maybe its just the type systems you've encountered ( see haskell for a type system that I would call non-broken ).
Think OOP languages are garbage? Maybe encountering something like Self will give you a different view of OO than what you get from C++ or Java. Maybe encountering CLOS will open your eyes to a different way of doing OOP.
Another bonus via anecdote:
I don't use Ruby anymore, but I still follow the community because people are doing interesting things, things I might want to steal an idea from and use in my language(s) of choice.
Seriously. I could care less the order of constructor evaluation in a multiple inheritance language. If that becomes a problem, I'll look it up.
This isn't like school where you try to pick one subject and become the complete overlord of it. This is about building a toolbox: learning how different tools work and being able to switch instantly between them when the time is right. The meta knowledge of languages is infinitely more important than the abstract details of a particular one. If you're a good programmer, you'll naturally optimize the code you write.
Thinking about writing a solution in an imperative language is fundamentally different than thinking about one in a functional language. Thinking about a web solution in terms of Javascript/client-side/jsonp is fundamentally different than in terms of client-server, or in terms of post-response. It's the thinking about those problems, before you start hacking, that gets you the most mileage. And the best way to learn how to think using those paradigms is to write solutions using them.
I think the primary advantage of knowing many languages is knowing when you're using the wrong tool for the job.
It would probably make you a better programmer to master all of purely functional programming, syntaxic abstraction, pattern-matching and logical inference, distributed and fault-tolerant computation by message-passing, stack-oriented programming, etc.
It just happens that some languages are predominantly based on each of those principles so the act of learning those languages in depth make you master those useful principles for free.
Haskell = Purely functional programming
Lisp = Syntaxic abstraction
Prolog = Pattern-matching and logical inference
Erlang = Distributed and fault-tolerant computation by message-passing
Forth = Stack-oriented programming
Every little bit helps. Read one book and you've learned a new point of view. Read that book and build a sample project and you've learned more. To really understand a language or framework requires still more work. To master it might take years.
You should master one or two things (or more, if there are enough hours in the day or if you are superhumanly good at mastering languages). But that doesn't mean that you shouldn't also have lower levels of expertise in a broad range of other subjects. Half the battle in life is knowing what to master at any given moment, and the only way to figure that out is to sample a lot of things.
Suppose, there is a guy (I will name him "Poluekt"), who is a master of Foo language (sounds like "a master of kung-Foo!"). Foo is a really good functional language having active community, excellent runtime and good libraries; Poluekt is good at writing in Foo but isn't brave enough to say "I'm not a Foo, I'm a programmer who wants to choose between languages when it comes to solving non-trivial problems".
What will happen with such a guy when he hear of nice features a new language (say, Bar) offers to solve problems in domain where Foo is (was?) the language of choice? Oh, it will be very offensive for our guy to hear that Bar beats Foo in some cases or even is press it. It will make Poluekt so unhappy, irritable...
Nobody knows how many Bars there will be on the Poluekt's way, but learning them seems a good way to become a good specialist.
Of course, a master knows its tools. He has many tools in his toolset and chooses the ones that better fit the task he is working at. Sometimes he may need to use a new tool, which he learns and adds to the toolset.
New languages rarely introduce substantially new concepts, mostly new ways to represent those concepts and put them together in a better way. However, if we are talking about new concepts, not just new languages, that is different. Other commenters have mentioned functional versus imperative programming style (enforced, or at least suggested, by the language) and so on. Learning new concepts makes us better programmers in older languages too.
But that is comfortably offset by the advantages you gain from seeing through the syntax to the language concepts. It is not even the correct question to ask really. Because mastering of a language might be a secondary goal.
A more interesting question might be: do I know at all which language I should strive to master? And that will require you to look at a few.
It's probably worth mentioning that the reality is that not every developer is of equal ability, nor has the same level of potential ability.
I've met many developers that clearly don't have the same capacity for learning and applying languages to problems as well as others. Do what works for you based on your own perceived capabilities.
Then again, I started out on C, so pretty much everything besides Haskell seems like a piece of cake.
By making you approach the same problems in different ways, new languages make you a more versatile programmer less tied to a particular technology while improving existing skills.
It's a subtle but very depressing aspect of working in PHP. I just feel sad working in PHP, in a way that I've perhaps never experienced in any other language. Maybe I'm just getting too old to read more crappy code, and it would improve if I started working on better written code. And maybe I was lucky enough to mostly work with good code in the past in those other languages.
To be fair, there are some things about PHP that are surprisingly good and worth looking to for inspiration: Ease of app deployment, marketing for a "good enough" product, allowing a very large community to contribute without muddying the waters too much (comments on doc pages, for example, rather than a wiki), solving the right problems at the right time (even poorly), etc. None of these are aspects of the language itself, only the resulting full experience that is PHP.
HOW FREAKY ARE YOU READY BE TO GET THE POINT OF MASTERING 2 OR MORE LANGUAGES ?
Most part of programmers are good at some languages, but not masters ... being a master of one is difficult, what if master of two or three.
So the answerer is : depends of the freaky behind the try !