Recs.
Updated
SpecsUpdate
Pros
Pro Haskell-like modules
Elm uses easy to use Haskell-like modules.
Use:
import List
import List as L
import List exposing (..)
import List exposing ( map, foldl )
import Maybe exposing ( Maybe )
import Maybe exposing ( Maybe(..) )
import Maybe exposing ( Maybe(Just) )
Creation:
module MyModule where
Pro Static module system
Elm uses easy to use modules.
Use:
import List
import List as L
import List exposing (..)
import List exposing ( map, foldl )
import Maybe exposing ( Maybe )
import Maybe exposing ( Maybe(..) )
import Maybe exposing ( Maybe(Just) )
Creation:
module MyModule exposing (foo, bar)
Pro Package manager enforces semantic versioning
The Elm package manager actually checks for API changes between package versions, classifies them as major/minor/patch, and will enforce proper version numbers appropriately. This means that you can safely update from (e.g.) version 3.1 to 3.2 of a package knowing that it won't break backwards compatibility.
Pro Great and simple way to learn Purely Functional Programming 
You can try to apply some functional programming ideas in other languages that have an imperative basis, but you haven't seen the real power unless you tried it in the environment of purely functional programming. Elm is a simple language with great learning resources and easy graphical output, which makes it easy to explore the power of functional programming. Plus programming in Elm is very readable.
Pro Awesome tooling
Elm Auto-completion is available for most editors. With Atom, for example, Elm plugins are available for linting, formatting, make/compiler support, auto-creating case statements, type-aware auto-complete, refactoring tools, and Elmjutsu will simply overflow you with super useful functions, like navigate to a referenced definition and show expression type. Plus the basic compiler messages.
Pro Higher confidence in code correctness and quality
Pure functions, immutable data structures, amazing compiler, clean and homologous syntax used for HTML, logic, and optionally to replace CSS, elimination of entire classes of bugs so you don't even need most unit tests. These factors lead to better code, better programs, higher confidence, and ultimately, more satisfaction.
Cons
Con Missing syntactic sugar ('where' clauses, pattern guards)
Elm is missing a lot of syntactic sugar that Haskellers may consider core, such as 'do' notation, 'where' clauses, pattern guards, and operator sections.
Con FRP is no longer part of Elm
The most "Wow-able" feature of Elm - Functional Reactive Programming (FRP) - is no longer part of Elm. It got removed in version 0.17 (http://elm-lang.org/blog/farewell-to-frp).
Con Breaking API changes
Migrating an application from 0.18 to 0.19 can be pretty hard due to breaking API changes.
On the positive side, though, the language author(s) want to keep the language and the platform clean and concise and don't want to leave any room for dragging old patterns along.
But if you have a large codebase then well... You might have to bite the bullet and spend a few days migrating your code.
It's just something people should be aware when adopting Elm.
Con Communication with userbase is restricted and often seems to be snippy
Evan the main dev of elm is against roadmaps and announcing what will happen up front. If he answers questions it is often in a bad tone.
i.e: https://groups.google.com/forum/#!msg/elm-dev/kNKilHjUYqo/3mTObqyGAgAJ
Con Not quite Haskell semantics
Elm is a strict language, semantically different from Haskell. Elm also borrows a lot from OCaml and F#. While this makes for a nice syntax, it does mean that, for the Haskell programmer, there may be some surprises when it comes to semantics or function names.
Recommendations
Comments
Flagged Pros + Cons
Pro Missing syntactic sugar
Easy to learn, most functions have only one way, not 5 alternatives where you must study where to best use what.
Con Not self-hosted
This is very important for the maturity of the language but can it be self hosted at all (if not it will be a fat valid con).
Pro Good tooling
All major editors have great support. With Atom for example, Elm plugins are available for linting, formatting, make/compiler support and Elmjutsu will simply overflow you with super useful functions, like navigate to referenced definition and show expression type.
Out of Date Pros + Cons
Pro Time-travelling debugger and Hot-swapping of code
Elms purity and high-level FRP primitives allow for similarly higher-level tools that other languages can only dream of.
Pro First class FRP and Reactive DOM
FRP is at the core of Elm philosophy, thus FRP constructs are really clean and simple to use and integrates really well with the rest of the others libraries.
FRP in Elm feels like Reactive Extensions (ReactiveX), so if you are used to this, Elm is probably the easiest way to go.