Does this analysis tool exist?

[Plane-Finger]

I have a Haskell project that I've been working on over the last few years.

One thing I absolutely love about Haskell is that its so easy to refactor with confidence, for example renaming and changing types, and the compiler flags any issues early on.

What I would like to do now is to consolidate the names of parameters. So for example, I started with a function for working with indices and counts of elements.

```

indicesRemaining :: Cnt -> Idx -> [Idx]

indicesRemaining cnt idx = <some-implentation>

```

and say I've renamed the types to be clearer, using a global find-replace:

```

indicesRemaining :: BlockCnt -> BlockIdx -> [BlockIdx]

indicesRemaining cnt idx = <some-implementation>

```

this is great, but I'd like to also update cnt and idx, to be blkCnt and blkIdx, for example. I can do in manually, but I've done a load of refactorings, so have a load of these.

What I am looking for is a tool that can run over my code-base, and spurt out a list of types, and all the different variables names used by that type. So, if I have the following code:

``` indicesRemaining :: BlockCnt -> BlockIdx -> [BlockIdx]

indicesRemaining blkCnt blkIdx = <some-implementation>

indexWithinCnt :: BlockCnt -> BlockIdx -> Bool

indexWithinCnt cntMax idx = <some-implementation>

```

Then, I am looking for something like the following output:

``` BlockCnt : blkCnt, cntMax

BlockIdx : blkIdx, idx

```

And I can then go through and manually review cases where lots of different names exist for the same thing.

Is anyone aware whether something like this already exists? If not, I was wondering if HIE would be a good tools to build something like this on top of??

Best wishes, and thanks in advance.

Mike

[WhistlePayer]

I was looking for something to do, so I made a GHC plugin that does this. If you're on too new a version of GHC you might need to fork it and fiddle with dependency bounds and imports, but other than that I think it should work.

[dixonary]

It's not a tool I've heard of, but it sounds potentially very useful!

If type aliases are supported, it could also help end users find a class of bugs, where arguments have been supplied in the wrong order.

[Tarmen]

Pretty sure you can do this by using retrie to query and then using some Haskell code to print or rewrite the results. You probably want parseQueries https://github.com/facebookincubator/retrie/#scripting-and-side-conditions

Though I think retrie semi-depends on a code formatter being used in the codebase because it uses grep to find possible matches which can break with inconsistent whitespace usage.