I don’t see why a Haskell program can’t be written with comments and with good naming to be somewhat understandable to a person without a great deal of studying. The example from Krzysztof or scm are both concise while staying easy to understand.

I’d like to understand whether this is because wordpress ate the comments from those haskell programs, or whether terseness is valued so highly by haskell programmers that comments go out the door. The same applies to variable naming.

The longest non-global variable name in the haskell programs is *two* characters long. It’s like C-programs from the 70s. With that kind of naming convention, documentation is *needed* to understand the idea behind a function. This again means that the code itself is unreadable.

matchBy matchFunc = null . foldl matchAll [] where
    matchAll []     c = [c]
    matchAll (s:ss) c | matchFunc s c = ss
                      | otherwise     = (c:s:ss)
matchBrackets = matchBy $ \x y -> (x,y) `elem` [('[',']'),('{','}'),('(',')')]

A parsing lib seems a bit heavyweight for this simple example IMO.

I’m posting a shorter and less dense solution to your problem below. Hope that helps


import Control.Monad
import System.Environment

main = getArgs >>= mapM (print . maybe False null . parse)


public class SimpleBraceParser {

  private int index = 0;
  private String s;

  public SimpleBraceParser(String s) { this.s = s; }

  private void skip(char c) {
    ++index;
  }

  private char currentChar() {
    if (index < s.length()) return s.charAt(index);
    else return ''; // Evil "sentinel" value
  }

  private void eat(char c) {
    if (currentChar() == c) {
      ++index;
      return;
    }
    throw new RuntimeException("parse error at " + index + ", expecting '" + c + "'");
  }

  public void parseRoundBrace() {
    skip('(');
    parseExpr();
    eat(')');
  }

  public void parseSquareBracket() {
    skip('[');
    parseExpr();
    eat(']');
  }

  public boolean parseExpr() {
    if (currentChar() == '(') {
      parseRoundBrace();
      return true;
    } else if (currentChar() == '[') {
      parseSquareBracket();
      return true;
    } else return false;
  }

  public void parseExprs() {
    while (parseExpr()) {
    }
  }

  public void parse() {
    parseExprs();
    if (currentChar() != '')
      throw new RuntimeException("not terminated correctly at " + index);
  }

  static boolean reportErrors = false;

  public static void main(String[] args) {
    for (String arg : args) {
      SimpleBraceParser p = new SimpleBraceParser(arg);
      try {
        p.parse();
        System.out.println("true");
      } catch (Exception e) {
        if (reportErrors) e.printStackTrace(System.err);
        System.out.println("false");
      }
    }
  }

}

Yep, it’s pretty long! I like top-down parsers as they are pretty intuitive. I’d use Antlr for any more serious parser work.

I really like the look at the Haskell version with Parsec. I tested your Haskell, Scala and Java versions along with my Java version and the Parsec version (amongst others). Your Haskell version and Parsec are very fast - Parsec is faster :). I only used /usr/bin/time to test so the JVM startup time could have hampered the Java solutions. My recursive Java version and your Scala version require stack-size increases (on my large inputs).

With the Scala version performance extremely poorly on large inputs. Pretty sure it doesn’t matter if the inputs are heavily nested or not. Maybe Scala isn’t the best language for functional style code. Are there any ways to improve the performance and stay functional?

def parse(s) { def t = s.replace(”[]“, “”).replace(”()”, “”); t == s ? t : parse(t) }
args.each { println parse(it) == “” }

A little less imperative:

brackets = ["[]“, “()”]
def parse2(s) { def t = brackets.inject(s){ a, b -> a.replace(b,”") }; t == s ? t : parse2(t) }

Anyway, thanks again for this nice setting. Could you be a bit more clear about the composability issues you were aiming at ?