It's an interesting idea.

I've actually gone the opposite way recently. In the past, I'd only have code highlighting. Different parts of the syntax would be rendered as different colors--nothing surprising.

However, recently I've been writing a lot of Haskell and OCaml. At least in Emacs, both Haskell and OCaml have an additional option to syntax highlighting with color: your code can also be highlighted with symbols. That is, parts of the syntax are not only displayed in a different color but actually displayed as a Unicode character rather than ASCII. As a moderately contrived example, something like

    \ a b c -> a >= b && b <= c || a /= c

would get displayed as:

    λ a b c → a ≥ b ∧ b ≤ c ∨ a ≢ c

Now, real code doesn't usually have symbols quite as dense; this example just shows a whole bunch of them at the same time.

I find the second snippet far easier to read than the first, especially if I'm just scanning over the code.

This is also a very good reason for using a typeface like Deja Vu Sans Mono: it can support all the symbols I could ever want. It's also very readable.

I personally find this, combined with syntax highlighting, extremely useful for reading code. Actually, thinking about this, I've found syntax highlighting even more useful for Haskell and OCaml than other languages, probably because they have very minimalist syntax. I really like the syntax, but the color does make the overall structure of any given function much more evident, which is nice.

Coincidentally, for the same readability reasons as above, I'm significantly warming up to Unicode identifiers. I think something like:

    set1 `union` set2

is not nearly as readable as

    set1 ∪ set2

And, as a bonus, the second version is easier to type:

    set1 \cup set2

Additionally, using Unicode identifiers and operators matches the way I write pseudocode. With the right identifiers, my Haskell code actually looks very close to what I would write on a whiteboard to explain some concept. That's one of the reasons I really like Haskell's syntax.

As an aside, the expression

    set1 `union` set2

is a perfect case study of why I find syntax highlighting useful. First of all, I think it's strictly better than the prefix version:

    union set1 set2

I've found being able to use arbitrary functions in an infix position can sometimes make certain expressions much more readable and natural.

However, if you're just scanning over the code, it might be easy to miss the backticks. Happily, in Emacs, operators get highlighted in a different color from normal identifiers. This includes things in backticks. So the `union` gets highlighted in a different color, making it obvious it's being used in an infix position.