Hacker News new | past | comments | ask | show | jobs | submit login

A hilarious example from the post:

    p_term :: Parser Term
    p_term = t <* spaces    
      where 
        t =     IntTerm               <$> p_num (readSigned readDec)
            <|> FloatTerm             <$> p_num (readSigned readFloat)
            <|> AtomTerm              <$> p_atom
            <|> TupleTerm             <$> p_tuple
            <|> BytelistTerm . C.pack <$> p_string
            <|> ListTerm              <$> p_list
            <|> BinaryTerm   . B.pack <$> p_binary
"Again, reading very naturally"



Seems pretty good to me. (I know a little Haskell, but only a little.) I think you and the original author are using different standards of readability. Yours: "If I look at this code, starting without knowing anything about it, does it look familiar?" His: "Once I've taken a few minutes to get the hang of this, is it easy to read and write?".

Here, the <|> and <$> and <* are unfamiliar and weird-looking: fair enough. But once you know that <|> means "or", and <$> means "try to parse some of the input using the thing on the right, and then the thing on the left is the resulting value", and <* means "try to parse both of these, and return the result of parsing the first one", it's hard to see how it could be much simpler.


Even in that code block, <|> and <$> both have roughly the common meanings of | and $ elsewhere in Haskell, which is the "next case" operator for pattern matching expressions and the strictness operator for ensuring that a function is applied to a value correctly.

Only <* is a really new construction.


...and the strictness operator for ensuring that a function is applied to a value correctly.

($) isn't any kind of strictness operator -- maybe you're thinking of ($!). ($) is a plain old function application operator.


It's strictness for applicative precedence, as ($) is the least of the operators, like a greedy open-paren.


I think this is very readable. Out of curiousity, what would your ideal of the equivalent code look like, in your language of choice? (If you really can't read this to know what your code would have to do, it's either parsing some term t or consuming whitespace. In the case where it parses a term, that term is going to be one of IntTerm, FloatTerm, AtomTerm, etc. Each term has its own associated parsing function (specified after the <$>).


I bet somewhere, people are laughing at perfectly nice pieces of python, lisp, or even Java. Just because it's new to them.

What did Gandhi say...


I don't think that block is that bad - it's just a combination of BNF and the normal pattern matching syntax, albeit with <_> operators.

There are examples of Haskell being needlessly hard to read - I'm not a fan of having optional significant whitespace in only some parts of the language, for example - but this isn't a great example.


It's notation, not a natural language stop treating it as such.


code readability is relative.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: