README: Added hello world and parser comparison

README.md

@@ -20,16 +20,70 @@ Lark can automagically build an AST from your grammar, without any more code on
 
 3. *Follows Python's Idioms*: Beautiful is better than ugly. Readability counts.
 
+## Hello World
+
+Here is a little program to parse "Hello, World!" (Or any other similar phrase):
+
+```python
+from lark import Lark
+l = Lark('''start: WORD "," WORD "!"
+            WORD: /\w+/
+            SPACE.ignore: " "
+         ''')
+print( l.parse("Hello, World!") )
+```
+
+And the output is:
+
+```python
+Tree(start, [Token(WORD, Hello), Token(WORD, World)])
+```
+
+Notice punctuation doesn't appear in the resulting tree. It's automatically filtered away by Lark.
+
+To learn more about Lark:
+ - Learn how to parse json at the [tutorial](/docs/json_tutorial.md)
 
 ## Features
 
  - EBNF grammar with a little extra
  - Earley & LALR(1)
  - Builds an AST automagically based on the grammar
+ - Automatic line & column tracking
  - Automatic token collision resolution (unless both tokens are regexps)
  - Python 2 & 3 compatible
  - Unicode fully supported
 
+## Coming soon
+
+These features are planned to be implemented in the near future:
+
+ - Grammar composition (in cases that the tokens can reliably signify a grammar change)
+ - Parser generator - create a small parser, indepdendent of Lark, to embed in your project.
+
+## Comparison to other parsers
+
+| Library | Algorithm | LOC | Grammar | Builds AST
+|:--------|:----------|:----|:--------|:------------
+| Lark | Earley/LALR(1) | 0.5K | EBNF+ | Yes! |
+| [PLY](http://www.dabeaz.com/ply/) | LALR(1) | 4.6K | Yacc-like BNF | No |
+| [PyParsing](http://pyparsing.wikispaces.com/) | PEG | 5.7K | Parser combinators | No |
+| [Parsley](https://pypi.python.org/pypi/Parsley) | PEG | 3.3K | EBNF-like | No |
+| [funcparselib](https://github.com/vlasovskikh/funcparserlib) | Recursive-Descent | 0.5K | Parser combinators | No |
+
+(*LOC measures lines of code of the parsing algorithm(s), without accompanying files*)
+
+It's hard to compare parsers with different parsing algorithms, since each algorithm has many advantages and disadvantages. However, I will try to summarize the main points here:
+
+- **Earley**: The most powerful context-free algorithm. It can parse all context-free grammars, and it's Big-O efficient. But, its constant-time performance is slow.
+- **LALR(1)**: The fastest, most efficient algorithm. It runs at O(n) and uses the least amount of memory. But while it can parse most programming languages, there are many grammars it can't handle.
+- **PEG**: A powerful algorithm that can parse all deterministic context-free grammars\* at O(n). But, it hides ambiguity, and takes a lot of memory to run.
+- **Recursive-Descent**: Fast for simple grammars, and simple to implement. But poor in Big-O complexity.
+
+Lark offers both Earley and LALR(1), which means you can choose between the most powerful and the most efficient algorithms, without having to change libraries.
+
+(\* *According to Wikipedia, it remains unanswered whether PEGs can really parse all deterministic CFGs*)
+
 ## License
 
 Lark uses the GPL3 license.

lark/lexer.py

@@ -21,7 +21,7 @@ class Token(Str):
 
 
     def __repr__(self):
-        return 'Token(%s, %s, %s)' % (self.type, self.value, self.pos_in_stream)
+        return 'Token(%s, %s)' % (self.type, self.value)
 
 class Regex:
     def __init__(self, pattern, flags=()):