Curious programmers are always wondering what language to learn next. Here's a list of the ones that I know, and some perceived reasons for why one would want to learn them.
Considered one of the ultimate safe imperative and object-oriented languages, Ada excels at memory safety. It's also designed for programming "in the large" and has a high readability factor. Of course, that means you'll be typing a lot, but at least it will still make sense when you come back to it in six months.
Even in these modern times, serious programmers can't not learn C. It will learn you something new about memory management, to be sure; especially when you're trying to figure out where that suddenly invalid pointer came from! Download and learn GDB before attempting, but you're sure to learn a lot about lower-level programming with this language.
This is basically C on crazy power-boosting steroids. The object-oriented capabilities are nearly feature-complete (lacking only in the use of primitive types), and templates rule for generic programming. Definitely worth it for anybody wanting to see some low-level details of object-oriented programming.
One of the older functional languages, and just as potent as it is ancient. Many argue that features of other languages can be much more elegantly implemented in Lisp, and many practitioners accept Greenspun's Tenth Rule. Of especial interest are macros, and the notion that code and data are represented identically, easily yielding programs that write programs.
Borrowing some of the best features from Prolog and adding intrinsically cool capabilities like ultra-lightweight threads, Erlang is a unique programming language. One of the things that hangs up new programmers is the fact that single-assignment is always in effect: once you bind a value to a name (other languages would call it a variable, but in Erlang they don't vary) that binding exists for the rest of the scope that contains it. You can't update the contents of a variable without some tricks. This seems restrictive, but once you get used to the functional style, it becomes second nature.
Because values are only bound once, concurrency is a lot easier to manage; you don't have to worry about state changing underneath you. And concurrency is something that Erlang does very well. Each thread is implemented within the virtual machine, but is extremely lightweight, and the virtual machine can usually run on multiple CPUs, thus granting true multi-processing power. Threads use a message-passing protocol, so there is no shared state to manage.
If you want to have a lot of friends, learn Java. Probably 99% of all firms use this in some aspect or another. As far as language features go, there aren't many killers. But it does have a good modularisation system, and many implementations have very extensive libraries to build your code off of.
A purely functional programming language with non-strict evaluation, Haskell is an incredibly powerful if extremely strange language. Well, strange until you get your head around it, upon which moment the skies will open and the sun shall shine through. Programming in Haskell often has those eureka moments when suddenly you realize that the ten-line function you just wrote can be expressed in just one point-free line.
Type safety is a big thing in Haskell; being very cleverly statically typed, the compiler can infer the types of most expressions from context, and appropriately warn you when you are trying to do something illegal. It's been said that when you get your program to pass the type-checker, you have some kind of useful program; it may not do exactly what you intended, but it does do something interesting. To get around polymorphism issues, Haskell also provides type classes, a way of specifying groups of types which support similar operations. For example: numbers, characters, and strings can all be ordered, thus they all belong to the Ord type class and any time you use < or > with values of these types, you'll get the answer you expect.
Laziness is another neat feature of Haskell; nothing is evaluated until it is needed, so it's possible to take the first three values of an infinite list. One problem with this is that it removes the notion of sequential operations, and this is an important premise for anything which is to have an external stateful effect, like display output. To get around this, Haskell uses monads, which allow operations to be sequenced and have side-effects while preventing the rest of the program from becoming tainted.
There are some pretty neat libraries that are either specific to or very well implemented in Haskell. One is Parsec, a very easy-to-use parser combinator library which makes it quick to write a parser in Haskell. Another is the STM library, which adds simple and effective parallelization based on transactional memory. Because of the language features in Haskell, concurrency is something that it excels at.
This is considered a more pure version of Lisp. The specification for Scheme is much smaller than that for ANSI Common Lisp, because the language is much simpler and provides less framework for programmers. One thing that Scheme features over Lisp, however, is the use of continuations for a variety of purposes.