implement dependents <x>, dependencies <x>, and debug.file

[aryairani]

Overview

This PR adds three commands.

debug.file

I can use debug.file to see the hashes of the last typechecked file.

Given this .u file:

type outside.A = A Nat outside.B
type outside.B = B Int
outside.c = 3
outside.d = c < (p + 1)

type inside.M = M outside.A
inside.p = c
inside.q x = x + p * p
inside.r = d

.> 

  I found and typechecked these definitions in u.u. If you do an `add` or `update`, here's how your
  codebase would change:
  
    ⍟ These new definitions are ok to `add`:
    
      type inside.M
      type outside.A
      type outside.B
      inside.p  : Nat
      inside.q  : Nat -> Nat
      inside.r  : Boolean
      outside.c : Nat
      outside.d : Boolean
   
  Now evaluating any watch expressions (lines starting with `>`)... Ctrl+C cancels.

.> debug.file

  type inside.M#4idrjau939
  type outside.A#0n4pbd0q9u
  type outside.B#muulibntaq
  inside.p#fiupm7pl7o
  inside.q#l5pndeifuh
  inside.r#im2kiu2hmn
  outside.c#msp7bv40rv
  outside.d#6cdi7g1oi2

This will help me make progress in some situations when UCM is being deficient or broken.

dependents / dependencies

But wait, there's more. I can check the dependencies and dependents of a definition:

.> add

  ⍟ I've added these definitions:
  
    type inside.M
    type outside.A
    type outside.B
    inside.p  : Nat
    inside.q  : Nat -> Nat
    inside.r  : Boolean
    outside.c : Nat
    outside.d : Boolean

.> dependents q

  #l5pndeifuh doesn't have any dependents.

.> dependencies q

  Dependencies of #l5pndeifuh:
  
    Hash          Name
    ##Nat.*       base.Nat.*
    ##Nat.+       base.Nat.+
    #fiupm7pl7o   inside.p

.> dependencies B

  Dependencies of #muulibntaq:
  
    Hash    Name
    ##Int   base.Int


  Dependencies of #muulibntaq#0:
  
    Hash          Name
    ##Int         base.Int
    #muulibntaq   outside.B

.> dependencies d

  Dependencies of #6cdi7g1oi2:
  
    Hash            Name
    ##Nat           base.Nat
    ##Nat.+         base.Nat.+
    ##Universal.<   base.Universal.<
    #fiupm7pl7o     inside.p
    #msp7bv40rv     outside.c

.> dependents d

  Dependents of #6cdi7g1oi2:
  
    Hash          Name
    #im2kiu2hmn   inside.r

.> 

I guess this will close #451, which asks for dependencies and/or transitive dependencies.

Implementation notes

We don't have an index for dependents of constructors, but iirc if you ask for that, it will show you dependents of the type that provided the constructor.

Working on this reminded me that LabeledDependency exists, and we could probably use it in more places to clean up implementations. LabeledReference would probably be a better name now.

-- constructor name is private, the module just exposes `fold`
newtype LabeledDependency = X (Either Reference Referent) deriving (Eq, Ord, Show)

I added the following function in HandleInput.hs, which looks similar to many others in there. It might be the best one ever, or it might be a duplicate, we'll have to take a look when we clean up that file.

resolveHQToLabeledDependencies 
  :: Functor m => HQ.HashQualified -> Action' m v (Set LabeledDependency)`

Testing

I caught some bugs through manual testing (e.g. fixed #1399), but it would be good to add some tests in not too long, to prevent regression. I haven't thought too much about what they'd look like, though.

Loose ends

• It might be nice if a query name was in the output too, but I am not too worried about it.
• It might be nice to have a flag to include transitive dependencies, but I am not too worried about it.

[aryairani]

¯\_(ツ)_/¯

[pchiusano]

Suggestion: I'd do column2sep (you'll have to write it, can pattern after column3sep, just add sep before the right column) to add an extra space between the columns, and I'd also add a header:

  P.column2Sep "  " $ [ (P.hiBlack "Hash", P.hiBlack "Name") ] ++ ...

Or maybe better yet, add a column2Header : Pretty -> Pretty -> [(Pretty, Pretty)] -> Pretty that encapsulates this pattern of adding a header.

It's also okay as is if you are out of steam, but I had a hard time parsing the current output and think above suggestion might help.

[pchiusano]

Looks good. Can you either do the following as part of this PR or create tickets to track the following (and if you disagree on any of these being a good idea LMK) -

1. Make dependents and dependencies commands produce numbered output
2. Add a transcript test (once the commands produce numbered output, create simple transcript to exercise)
3. Make these commands produce output just like find - show type signatures and whatnot

No need to address any/all of those in this PR I don't think, unless you are feeling inspired.

I left one other minor formatting suggestion on the output, also optional I think.

[pchiusano]

Suggestion: I'd do column2sep (you'll have to write it, can pattern after column3sep, just add sep before the right column) to add an extra space between the columns, and I'd also add a header:

  P.column2Sep "  " $ [ (P.hiBlack "Hash", P.hiBlack "Name") ] ++ ...

Or maybe better yet, add a column2Header : Pretty -> Pretty -> [(Pretty, Pretty)] -> Pretty that encapsulates this pattern of adding a header.

It's also okay as is if you are out of steam, but I had a hard time parsing the current output and think above suggestion might help.

[aryairani]

@pchiusano Sounds good. I'll add the column headings, then maybe do {1,2}, and open a ticket to track {3}.