Minor copy-editing on README.md (#196)

Slight punctuation and hyphenation improvements, with additional styling on command and directory names.

Author: johnlunney

README.md

@@ -5,7 +5,7 @@
 ## Overview
 
 Grumpy is a Python to Go source code transcompiler and runtime that is intended
-to be a near drop in replacement for CPython 2.7. The key difference is that it
+to be a near drop-in replacement for CPython 2.7. The key difference is that it
 compiles Python source code to Go source code which is then compiled to native
 code, rather than to bytecode. This means that Grumpy has no VM. The compiled Go
 source code is a series of calls to the Grumpy runtime, a Go library serving a
@@ -17,15 +17,15 @@ supported).
 ### Things that will probably never be supported by Grumpy
 
 1. `exec`, `eval` and `compile`: These dynamic features of CPython are not
-   supported by Grumpy because Grumpy modules consist of statically compiled Go
+   supported by Grumpy because Grumpy modules consist of statically-compiled Go
    code. Supporting dynamic execution would require bundling Grumpy programs
-   with the compilation toolchain which would be unwieldy and impractically
+   with the compilation toolchain, which would be unwieldy and impractically
    slow.
 
 2. C extension modules: Grumpy has a different API and object layout than
    CPython and so supporting C extensions would be difficult. In principle it's
    possible to support them via an API bridge layer like the one that
-   [JyNI](http://jyni.org) provides for Jython but it would be hard to maintain and
+   [JyNI](http://jyni.org) provides for Jython, but it would be hard to maintain and
    would add significant overhead when calling into and out of extension
    modules.
 
@@ -38,16 +38,16 @@ There are three basic categories of incomplete functionality:
    yet supported.
 
 2. Builtin functions and types: There are a number of missing functions and
-   types in `__builtins__` that have not been implemented. There are also a
+   types in `__builtins__` that have not yet been implemented. There are also a
    lot of methods on builtin types that are missing.
 
 3. Standard library: The Python standard library is very large and much of it
    is pure Python, so as the language features and builtins get filled out, many
    modules will just work. But there are also a number of libraries in CPython
-   that are C extension modules that need to be rewritten.
+   that are C extension modules which will need to be rewritten.
 
 4. C locale support: Go doesn't support locales in the same way that C does. As such,
-   some functionality that is locale dependent may not currently work the same as in
+   some functionality that is locale-dependent may not currently work the same as in
    CPython.
 
  To see the status of a particular feature or standard library module, click
@@ -68,7 +68,7 @@ echo "print 'hello, world'" | make run
 
 ### Method 2: grumpc:
 
-For more complicated programs you'll want to compile your Python source code to
+For more complicated programs, you'll want to compile your Python source code to
 Go using grumpc (the Grumpy compiler) and then build the Go code using `go
 build`.  First, write a simple .py script:
 
@@ -101,16 +101,16 @@ writing, you may need to change one or more of these.
 
 ### grumpc
 
-Grumpy converts Python programs into Go programs and grumpc is the tool
-responsible for parsing Python code and generating Go code from it. grumpc is
+Grumpy converts Python programs into Go programs and `grumpc` is the tool
+responsible for parsing Python code and generating Go code from it. `grumpc` is
 written in Python and uses the `ast` module to accomplish parsing.
 
-The grumpc script itself lives at tools/grumpc. It is supported by a number of
-Python modules in the compiler subdir.
+The grumpc script itself lives at `tools/grumpc`. It is supported by a number of
+Python modules in the `compiler` subdir.
 
 ### Grumpy Runtime
 
-The Go code generated by grumpc performs operations on data structures that
+The Go code generated by `grumpc` performs operations on data structures that
 represent Python objects in running Grumpy programs. These data structures and
 operations are defined in the `grumpy` Go library (source is in the runtime
 subdir of the source distribution).  This runtime is analogous to the Python C
@@ -119,13 +119,13 @@ counterparts in CPython.
 
 ### Grumpy Standard Library
 
-Much of the Python standard library is written in Python and so it "just works"
+Much of the Python standard library is written in Python and thus "just works"
 in Grumpy. These parts of the standard library are copied from CPython 2.7
 (possibly with light modifications). For licensing reasons, these files are kept
-in the third_party/stdlib subdir.
+in the `third_party/stdlib` subdir.
 
 The parts of the standard library that cannot be written in pure Python, e.g.
-file and directory operations, are kept in the lib subdir. In CPython these
+file and directory operations, are kept in the `lib` subdir. In CPython these
 kinds of modules are written as C extensions. In Grumpy they are written in
 Python but they use native Go extensions to access facilities not otherwise
 available in Python.