Use mapM_ rather than mapM in the Section visitor

To make it clear that we don't care about the results, only the state.

Add Section visitor

It's job is to check which kinds of annotations we have, in order to decide
which sections we need to render.

I am probably doing something clowny with the way I am mashing uniplate and
lenses etc together, but it does seem to work. That last `get`/`put` case is a
smell, but needed it given my use of `cosmosOf`; not sure how to avoid that.
Also, not sure why `mapM` does the right thing here, but it does.

Try to trick linter about duplication

It's been warning about this since forever:

```
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:202:7

lib/Docvim/Parse.hs:164:7: Warning: Reduce duplication
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:285:7
```

However, it is too smart. Even with this change, it still complains:

```
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:282:7

lib/Docvim/Parse.hs:165:7: Suggestion: Reduce duplication
Found:
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:203:7
```

This one is tricky to factor out because of the dependence on bindings visible
within the scope of the defined functions, and also the monadic execution
context. I think the linter *is* probably right that there is a code smell here,
though; I just have to figure out how to remove it.

Add @option headings to Markdown printer

Add a target for |:Command| links in Markdown

Remove unnecessary explicit anchors in headings

GitHub is going to add them anyway. Note that our |:Ack| links
don't work, because we aren't rendering that link target (we should).

Do some linkification in the Markdown printer

This is provisional as I think putting the explicit link targets in the heading
for GitHub is wrong.

Teach Markdown printer about @mapping and @command

Add @mapping support to Vim printer

Get @command annotation working

Make wrapping aware of concealed characters

This is the cheap-but-approximate approach. Results are reasonable, costs are
very low, and the consequences of being (slightly) wrong are livable. Let's go
with this for now.

Kill a stray comment

Use worktree as issue tracker

Taking standards to new lows.

Fix misplaced whitespace in output

Add test showing @option output

Something buggy in the parser: note that we have to explicitly say "none" for
the no-default case, but I intended that to be simply omittable.

Print options

Alignment will need a bit of work here, but this is a good first draft.

Specifically, if we want things to look like this in the UI:

                                g:SomeOpt
    g:SomeOpt        string (default: 10)

The output will actually need to be:

                                *g:SomeOpt*
    |g:SomeOpt|        string (default: 10)

Because `|` and `*` don't take up any width due to being concealed by Vim.

Fix lints

Use actual max int rather than hard-coded constant

Handle overlength headings

#uglycode

Fix duplicate content

Initial cut at @mapping, @command, @option, @function

Still some bugs to sort out (eg. duplicate symbol table entry due to extra
`MappingsAnnotation` when we perform extraction) and polish to apply (not
actually printing the options/functions etc).

Make Vim headings work by colocating link targets on same line

Add entries to symbol table for generated headings

Autogen headings in Vim printer too

Add auto-generated headings to Markdown printer

For @functions, @commands, @mappings, @options.

Add basic support for @options, @functions and @commands annotations

Still need to auto-emit headings for these, but I think they basically work.
Also need to make `Option`, `Function` and `Command` visitors.

Overhaul testing and compilation

We now "compile" in the test suite, meaning that we pipe our translation units
through the various extraction transforms after parsing. This means three main
things:

- Everything is nested inside a `Project` node type now, consisting of one or
  more translation units.
- Nodes within the project are ordered (or reordered) to maintain desired
  section ordering.
- As we add more phases to "compilation" (eg. automated insertion of table
  of contents etc), these will get reflected in the test suite automatically.

As part of this, extracted test-specific bits out into a new `Util` module (ie.
pretty-printing methods, convenience functions) and the "compile" pipeline into
a `Compile` module.

Add a missing type annotation

Don't rely on transformers

Don't want two monad transformer libraries at play here
needlessly.

Kill off an out-of-date comment

Fix copy pasta error

Suprised neither the compiler nor the tests seemed to
complain about this.

DRY up other visitors

More simplification

Trim down imports

More DRYing

Further visitor DRYing

Tidy indentation

Fix lints

Extract Visitor module

First step in factoring out some of the duplication here.

Remove some old comments

Fix indentation

Suppress unwanted trailing whitespace

Further refine hard-wrapping

Be better about hard-wrap placement

Still needs a refactor, but the output is better.

Rename `hardwrap` -> `textwidth`

Because I want to use the name `hardwrap` for a function as part of some
imminent refactoring.

Align

Always link unconditionally in Vim help output

May not even need the symbol table at all in this printer, but we'll keep it
around for now, just in case.

Replace a literal that I missed with a constant

Move hardwrapping from `plaintext` into `append`

Solves a bunch of issues, creates others, which I will have to fix in a
follow-up. The code itself is a complex, fragile, ugly, clusterfuck, so consider
this a work-in-progress.

Additionally, there are some unfortunate breaks which were there before and
continue to be there, like just inside parens, and things like that. Will need
to sort all that out too.

Tidy

Get rid of meaningless distinction in Markdown printer

All the cases must return Env, so let's put them all together
whether or not they explicitly access the state.

Share integration tests inputs across output types

May eventually share other things too (I still have some
manual symlinks going on), but this is a good start.

Make slurping a little more robust

But note remaining caveat inline. This really
should only be used to trim whitespace, at least
for now.

Remove unwanted blank lines before fenced code blocks

But note that this is a little bit fragile, even though
the tests pass. More work can be done to make this more
robust.

Fix some lints

Reorder things

Eliminate unwanted trailing whitespace

Initial primitive cut at hard wrapping

This isn't ideal as noted inline (no rollback yet, which means we wind up with
trailing whitespace), but it is a reasonable start.

Remove last use of Append

Convert one more `Append`

Continue `Append` -> `append` conversion

Update `fenced` to use `append`

I wanted to write this using `>>=` but evidently that is not the right tool.

Inline `return` call inside `fenced` function

Step 1 of ?.

Drop excess blank lines after fenced code blocks in Vim output

Create append helper and start using it

Feel the linter love

Get some TODOs out of the work tree

Horrible hygiene I know, but I need to compensate the functional purity somehow.

Add partial line to Vim printer context

This will be used to perform current line width calculations, so that we can
decide whether or not to hard-wrap.

Use operations list in Vim printer

Let's see if I can use this to implement hard-wrapping. It is very ugly, but if
I can get it working I'll have some tests in place and can then try refactoring.

Deal with linebreaks inside list items

Fix unwanted stripping of leading whitespace

Stripping trailing whitespace is desired, but the leading
strip was actually busting the output.

Fix excess line at break tags in blockquotes

Add some tests

Revealing some still-unresolved issues to be fixed.

Show how linebreaks can be contextual

Further flesh out README

Even sillier example of putting monadic state

Silly demonstration of getting at monadic state

Doesn't affect the output, but proves that I can `get` the state.

Use State + Reader monad transformer stack

Doesn't do anything useful yet, but it will: I want to use this to track current
line width, for the purposes of wrapping. As noted here:

https://ro-che.info/articles/2012-01-02-composing-monads

The order in which I compose the State and Reader monad transformers shouldn't
matter at all. If I end up needing Writer too, I will be able to replace this
with the RWS monad transformer.

Add some fixture files that I previously forgot to include

Fix indentation

Rename `State` to `Metadata`

State was a terrible name to use in conjunction with the Reader monad, as it
easily leads to confusion with the State monad. Let's just call it `Metadata`
(about the project AST) for now; that's a horribly generic name too, but it is
at least an improvement.

Update .tmux paths for Vim 8-pre

Fix lint

Upgrade README

Hook up plugin and footer extraction

Obviously the horrible `ast2` binding name will have to go away, but this works.

Extract footers and plugin sections

Fix trailing whitespace at end of file

Actually write output files

Simplify some case statements with the LambdaCase extension

Via:

  https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/basic-syntax-extensions

Use MultiWayIf extension to make a nested `if` less ugly

Still pretty ugly though...

Via:

  https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/basic-syntax-extensions

Sort link targets for Markdown output too

Sort link targets

Right-align link targets

Start prepping to hangle hard-wrapping

This is going to be ugly...

Fix @plugin printing in Vim printer

Make Vim printer more useful

Still a work-in-progress, but it is close to what we want now.

Fix some lints

Fix test breakage caused by missing modules

Add Mappings visitor

Add extract function to Plugin visitor

Lots of duplication/similarity with the Footer visitor, but I want to do this a
few times before I dry to identify and abstract away the pattern.