Repository navigation
Expand file tree
/
Copy pathweeder.toml
More file actions
894 lines (890 loc) · 45.5 KB
/
Copy pathweeder.toml
File metadata and controls
894 lines (890 loc) · 45.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
### This file should be seen as documenting the public API.
###
### For applications, there is only `main`, but there are packages that are treated as independent libraries (often
### under `Unison.Util`) and there is an API used by Share.
## NB: The strings are triple-single-quoted to allow them to contain single quotes. It’s easier to be consistent than to
## special case each one.
root-instances = [
## Allow “negative” instances, which are necessarily unused.
{ instance = '''^\((.* )?TypeError .*\) => .*''' },
## Principled classes – even if we’re not using them, they have a single reasaonable implementation, and many of
## them can be derived.
##
## NB: These classes aren’t always in the module you might expect, but it’s the canonical one.
{ class = '''^Data\.Bifoldable\.Bifoldable$''' },
{ class = '''^Data\.Bifunctor\.Bifunctor$''' },
{ class = '''^Data\.Bitraversable\.Bitraversable$''' },
{ class = '''^Data\.Foldable\.Foldable$''' },
{ class = '''^Data\.Functor\.Classes\.Eq1$''' },
{ class = '''^Data\.Functor\.Classes\.Eq2$''' },
{ class = '''^Data\.Functor\.Classes\.Ord1$''' },
{ class = '''^Data\.Functor\.Classes\.Ord2$''' },
{ class = '''^Data\.Functor\.Classes\.Read1$''' },
{ class = '''^Data\.Functor\.Classes\.Read2$''' },
{ class = '''^Data\.Functor\.Classes\.Show1$''' },
{ class = '''^Data\.Functor\.Classes\.Show2$''' },
{ class = '''^Data\.Traversable\.Traversable$''' },
{ class = '''^GHC\.Base\.Functor$''' },
{ class = '''^GHC\.Base\.Monoid$''' },
{ class = '''^GHC\.Classes\.Eq$''' },
{ class = '''^GHC\.Classes\.Ord$''' },
{ class = '''^GHC\.Generics\.Generic$''' },
{ class = '''^GHC\.Generics\.Generic1$''' },
{ class = '''^GHC\.Read\.Read$''' },
{ class = '''^GHC\.Show\.Show$''' },
{ class = '''^GHC\Base\.Semigroup$''' },
]
root-modules = [
## Modules that have “independent” APIs (but should probably get tests and/or extracted to independent repos).
'''^EasyTest$''',
'''^System\.Path$''',
'''^Unison\.Util\.BiMultimap$''',
'''^Unison\.Util\.Logger$''',
'''^Unison\.Util\.Relation$''',
'''^Unison\.Util\.Relation3$''',
'''^Unison\.Util\.Relation4$''',
'''^Unison\.Util\.Rope''',
## Debugging tools – not used in production, but often enabled during development.
'''^Unison\.Debug''',
'''^Unison\.Runtime\.Debug''',
]
roots = [
'''^Main\.main$''',
'''^Paths_.*$''',
## Share API – used by the Share server and CLI.
'''^Unison\.Auth\.CredentialFile\.atomicallyModifyCredentialsFile$''',
'''^Unison.Share.Types\.[^\.]+$''',
'''^Unison\.Auth\.CredentialManager\.saveCredentials$''',
'''^Unison\.Auth\.CredentialManager\.CredentialManager$''',
'''^Unison\.Auth\.CredentialManager\.globalCredentialManager$''',
'''^Unison\.Auth\.CredentialManager\.getCodeserverCredentials$''',
'''^Unison\.Auth\.CredentialManager\.getOrCreatePersonalKey$''',
'''^Unison\.Auth\.CredentialManager\.isExpired$''',
'''^Unison\.Auth\.CredentialManager\.getCredentials$''',
'''^Unison\.Auth\.CredentialManager\.newCredentialManager$''',
'''^Unison\.Auth\.Types\.emptyCredentials$''',
'''^Unison\.Auth\.Types\.Code$''',
'''^Unison\.Auth\.Types\.OAuthState$''',
'''^Unison\.Auth\.Types\.PKCEVerifier$''',
'''^Unison\.Auth\.Types\.PKCEChallenge$''',
'''^Unison\.Auth\.Types\.codeserverCredentials$''',
'''^Unison\.Auth\.Types\.getCodeserverCredentials$''',
'''^Unison\.Auth\.Types\.setCodeserverCredentials$''',
'''^Unison\.Auth\.Types\.codeserverFromURI$''',
'''^Unison\.Auth\.Types\.codeserverIdFromURI$''',
'''^Unison\.Auth\.Types\.codeserverIdFromURIAuth$''',
'''^Unison\.Auth\.Types\.codeserverIdFromCodeserverURI$''',
'''^Unison\.Auth\.Types\.codeserverBaseURL$''',
'''^Unison\.Server\.HistoryComments\.API.api$''',
'''^Unison\.Server\.HistoryComments\.API.API$''',
'''^Unison\.Server\.HistoryComments\.API.Routes$''',
## Entries below here have been grandfathered in and should be reviewed.
'''^U\.Codebase\.Branch\.Type\.hoist$''',
'''^U\.Codebase\.Branch\.Type\.hoistCausalBranch$''',
'''^U\.Codebase\.Causal\.emap$''',
'''^U\.Codebase\.Causal\.hoist$''',
'''^U\.Codebase\.Decl\.rmap$''',
'''^U\.Codebase\.Reference\._RReferenceReference$''',
'''^U\.Codebase\.Referent\.typeRef_$''',
'''^U\.Codebase\.Referent\.termRef_$''',
'''^U\.Codebase\.Referent\.toReference$''',
'''^U\.Codebase\.Referent\.toReferenceId$''',
'''^U\.Codebase\.Referent\.toTermReference$''',
'''^U\.Codebase\.Referent\.toShortHash$''',
'''^U\.Codebase\.Sqlite\.Branch\.Full\.branchCausalHashes_$''',
'''^U\.Codebase\.Sqlite\.Branch\.Full\.t_$''',
'''^U\.Codebase\.Sqlite\.Branch\.Full\.h_$''',
'''^U\.Codebase\.Sqlite\.Branch\.Full\.p_$''',
'''^U\.Codebase\.Sqlite\.Branch\.Full\.c_$''',
'''^U\.Codebase\.Sqlite\.Decode\.decodeTermElementWithType$''',
'''^U\.Codebase\.Sqlite\.LocalIds\.t_$''',
'''^U\.Codebase\.Sqlite\.LocalIds\.h_$''',
'''^U\.Codebase\.Sqlite\.Operations\.loadCausalHashAtPath$''',
'''^U\.Codebase\.Sqlite\.Operations\.expectCausalHashAtPath$''',
'''^U\.Codebase\.Sqlite\.Operations\.loadCausalBranchAtPath$''',
'''^U\.Codebase\.Sqlite\.Operations\.loadBranchAtPath$''',
'''^U\.Codebase\.Sqlite\.Operations\.c2sTextReference$''',
'''^U\.Codebase\.Sqlite\.Operations\.s2cTextReference$''',
'''^U\.Codebase\.Sqlite\.Operations\.s2cTextReferent$''',
'''^U\.Codebase\.Sqlite\.Operations\.c2sTextReferent$''',
'''^U\.Codebase\.Sqlite\.Operations\.diffPatch$''',
'''^U\.Codebase\.Sqlite\.Operations\.loadTermWithTypeByReference$''',
'''^U\.Codebase\.Sqlite\.Operations\.loadDbBranchByCausalHashId$''',
'''^U\.Codebase\.Sqlite\.Operations\.expectDbBranchByCausalHashId$''',
'''^U\.Codebase\.Sqlite\.Operations\.saveDbBranch$''',
'''^U\.Codebase\.Sqlite\.Operations\.before$''',
'''^U\.Codebase\.Sqlite\.Operations\.declReferencesByPrefix$''',
'''^U\.Codebase\.Sqlite\.Operations\.namespaceHashesByPrefix$''',
'''^U\.Codebase\.Sqlite\.Operations\.dependentsOfComponent$''',
'''^U\.Codebase\.Sqlite\.Operations\.derivedDependencies$''',
'''^U\.Codebase\.Sqlite\.Operations\.appendProjectReflog$''',
'''^U\.Codebase\.Sqlite\.Operations\.expectProjectAndBranchNames$''',
'''^U\.Codebase\.Sqlite\.Patch\.Format\.localPatchToPatch'$''',
'''^U\.Codebase\.Sqlite\.Patch\.Full\.patchT_$''',
'''^U\.Codebase\.Sqlite\.ProjectReflog\.project_$''',
'''^U\.Codebase\.Sqlite\.ProjectReflog\.branch_$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectCausalByCausalHash$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectBranchHash$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectBranchHashForCausalHash$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectTextCheck$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadPatchObject$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectTermObject$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectObjectWithHashIdAndType$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectObjectIdForAnyHashId$''',
'''^U\.Codebase\.Sqlite\.Queries\.expectHashIdsForObject$''',
'''^U\.Codebase\.Sqlite\.Queries\.hashIdWithVersionForObject$''',
'''^U\.Codebase\.Sqlite\.Queries\.saveCausalParents$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadCausalParentsByHash$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadWatchKindsByReference$''',
'''^U\.Codebase\.Sqlite\.Queries\.getTypeReferenceForReferent$''',
'''^U\.Codebase\.Sqlite\.Queries\.getTypeReferencesForComponent$''',
'''^U\.Codebase\.Sqlite\.Queries\.getTypeMentionsReferencesForComponent$''',
'''^U\.Codebase\.Sqlite\.Queries\.fixupTypeIndexRow$''',
'''^U\.Codebase\.Sqlite\.Queries\.getDependentsForDependencyComponent$''',
'''^U\.Codebase\.Sqlite\.Queries\.getDependencyIdsForDependent$''',
'''^U\.Codebase\.Sqlite\.Queries\.getDependenciesBetweenTerms$''',
'''^U\.Codebase\.Sqlite\.Queries\.namespaceHashIdByBase32Prefix$''',
'''^U\.Codebase\.Sqlite\.Queries\.checkBranchExistsForCausalHash$''',
'''^U\.Codebase\.Sqlite\.Queries\.projectExists$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadProjectAndBranchNames$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadRemoteProject$''',
'''^U\.Codebase\.Sqlite\.Queries\.setRemoteProjectName$''',
'''^U\.Codebase\.Sqlite\.Queries\.loadRemoteBranch$''',
'''^U\.Codebase\.Sqlite\.Queries\.setRemoteProjectBranchName$''',
'''^U\.Codebase\.Sqlite\.Serialization\.getTypeFromTermAndType$''',
'''^U\.Codebase\.Sqlite\.Serialization\.lookupTermElement$''',
'''^U\.Codebase\.Sqlite\.Serialization\.decomposeWatchFormat$''',
'''^U\.Codebase\.Sqlite\.Serialization\.recomposeWatchFormat$''',
'''^U\.Codebase\.Sync\.transformSync$''',
'''^U\.Codebase\.Sync\.transformProgress$''',
'''^U\.Codebase\.Term\.rmapPattern$''',
'''^U\.Codebase\.Term\.dependencies$''',
'''^U\.Codebase\.Type\.typeD2T$''',
'''^U\.Util\.Serialization\.getFromBytes$''',
'''^U\.Util\.Serialization\.getFromFile$''',
'''^U\.Util\.Serialization\.getFromFile'$''',
'''^U\.Util\.Serialization\.putWithParentDirs$''',
'''^U\.Util\.Serialization\.putShortText$''',
'''^U\.Util\.Serialization\.getShortText$''',
'''^U\.Util\.Serialization\.putShortByteString$''',
'''^U\.Util\.Serialization\.getShortByteString$''',
'''^U\.Util\.Serialization\.lookupFramedArray$''',
'''^U\.Util\.Term\.text$''',
'''^IntegrationTests\.ArgumentParsing\.defaultArgs$''',
'''^ArgParse\.runDesc$''',
'''^ArgParse\.readAbsolutePath$''',
'''^ArgParse\.readPath'$''',
'''^U\.Codebase\.Branch\.Diff\.hoistTreeDiff$''',
'''^U\.Codebase\.Branch\.Diff\.nameBasedDiff$''',
'''^U\.Codebase\.Projects\.inferDependencyMounts$''',
'''^Unison\.ABT\.wrap$''',
'''^Unison\.ABT\.wrap'$''',
'''^Unison\.ABT\.annotate$''',
'''^Unison\.ABT\.absr$''',
'''^Unison\.ABT\.absr'$''',
'''^Unison\.ABT\.cycler'$''',
'''^Unison\.ABT\.cycler$''',
'''^Unison\.ABT\.fresh$''',
'''^Unison\.ABT\.occurrences$''',
'''^Unison\.ABT\.find'$''',
'''^Unison\.ABT\.Normalized\.freshen$''',
'''^Unison\.ABT\.Normalized\.transform$''',
'''^Unison\.Builtin\.constructorType$''',
'''^Unison\.Builtin\.builtinTypeDependentsOfComponent$''',
'''^Unison\.Builtin\.termRefTypeReferences$''',
'''^Unison\.Builtin\.Decls\.testResultListRef$''',
'''^Unison\.Builtin\.Decls\.ioErrorRef$''',
'''^Unison\.Builtin\.Decls\.tlsSignedCertRef$''',
'''^Unison\.Builtin\.Decls\.tlsPrivateKeyRef$''',
'''^Unison\.Builtin\.Decls\.filePathRef$''',
'''^Unison\.Builtin\.Decls\.avroDefaultNull$''',
'''^Unison\.Builtin\.Decls\.avroDefaultBoolean$''',
'''^Unison\.Builtin\.Decls\.avroDefaultInt$''',
'''^Unison\.Builtin\.Decls\.avroDefaultLong$''',
'''^Unison\.Builtin\.Decls\.avroDefaultFloat$''',
'''^Unison\.Builtin\.Decls\.avroDefaultDouble$''',
'''^Unison\.Builtin\.Decls\.avroDefaultBytes$''',
'''^Unison\.Builtin\.Decls\.avroDefaultString$''',
'''^Unison\.Builtin\.Decls\.avroDefaultArray$''',
'''^Unison\.Builtin\.Decls\.avroDefaultMap$''',
'''^Unison\.Builtin\.Decls\.avroDefaultRecord$''',
'''^Unison\.Builtin\.Decls\.avroDefaultEnum$''',
'''^Unison\.Builtin\.Decls\.avroDefaultUnion$''',
'''^Unison\.Builtin\.Decls\.avroDefaultFixed$''',
'''^Unison\.Builtin\.Decls\.avroDefaultNamedType$''',
'''^Unison\.Builtin\.Decls\.avroLogicalStringUUID$''',
'''^Unison\.Builtin\.Decls\.avroLogicalBytesDecimal$''',
'''^Unison\.Builtin\.Decls\.okConstructorReferent$''',
'''^Unison\.Builtin\.Decls\.failConstructorReferent$''',
'''^Unison\.Builtin\.Decls\.avroDefaultRef$''',
'''^Unison\.Builtin\.Decls\.ioErrorType$''',
'''^Unison\.Builtin\.Decls\.filePathType$''',
'''^Unison\.Builtin\.Decls\.tlsSignedCertType$''',
'''^Unison\.Cli\.Monad\.withE$''',
'''^Unison\.Cli\.MonadUtils\.getCurrentProjectName$''',
'''^Unison\.Cli\.MonadUtils\.getCurrentProjectBranchName$''',
'''^Unison\.Cli\.MonadUtils\.resolvePath'ToAbsolute$''',
'''^Unison\.Cli\.MonadUtils\.resolveAbsBranchId$''',
'''^Unison\.Cli\.MonadUtils\.resolveAbsBranchIdV2$''',
'''^Unison\.Cli\.MonadUtils\.resolveBranchId$''',
'''^Unison\.Cli\.MonadUtils\.resolveBranchIdToAbsBranchId$''',
'''^Unison\.Cli\.MonadUtils\.getMaybeBranch0FromProjectPath$''',
'''^Unison\.Cli\.MonadUtils\.assertNoBranchAtPath'$''',
'''^Unison\.Cli\.MonadUtils\.stepAt'$''',
'''^Unison\.Cli\.MonadUtils\.stepAtM$''',
'''^Unison\.Cli\.MonadUtils\.stepManyAt'$''',
'''^Unison\.Cli\.MonadUtils\.stepManyAtM$''',
'''^Unison\.Cli\.NameResolutionUtils\.resolveHQToLabeledDependencies$''',
'''^Unison\.Cli\.NamesUtils\.currentProjectRootNames$''',
'''^Unison\.Cli\.NamesUtils\.projectBranchNames$''',
'''^Unison\.Cli\.Pretty\.displayBranchHash$''',
'''^Unison\.Cli\.Pretty\.prettyBranchId$''',
'''^Unison\.Cli\.Pretty\.prettyBranchRelativePath$''',
'''^Unison\.Cli\.Pretty\.prettyDeclPair$''',
'''^Unison\.Cli\.Pretty\.prettyLabeledDependencies$''',
'''^Unison\.Cli\.Pretty\.prettyNamespaceKey$''',
'''^Unison\.Cli\.Pretty\.prettyWriteRemoteNamespace$''',
'''^Unison\.Cli\.Pretty\.shareOrigin$''',
'''^Unison\.Cli\.ProjectUtils\.justTheIds$''',
'''^Unison\.Cli\.ProjectUtils\.justTheIds'$''',
'''^Unison\.Cli\.ProjectUtils\.loadRemoteProjectBranchByName$''',
'''^Unison\.Cli\.ProjectUtils\.loadRemoteProjectBranchByNames$''',
'''^Unison\.Cli\.ProjectUtils\.expectRemoteProjectBranchByTheseNames$''',
'''^Unison\.Cli\.TypeCheck\.typecheckTerm$''',
'''^Unison\.Codebase\.expectTypeOfReferent$''',
'''^Unison\.Codebase\.dependentsOfComponent$''',
'''^Unison\.Codebase\.filterTermsByReferentHavingType$''',
'''^Unison\.Codebase\.filterTermsByReferentHavingTypeByReference$''',
'''^Unison\.Codebase\.isTerm$''',
'''^Unison\.Codebase\.isType$''',
'''^Unison\.Codebase\.resolveShortHash$''',
'''^Unison\.Codebase\.Branch\.UpdateStrategy$''',
'''^Unison\.Codebase\.Branch\.Raw\.Star$''',
'''^Unison\.Codebase\.Branch\.Raw\.EditHash$''',
'''^Unison\.Codebase\.Branch\.Raw\.Raw$''',
'''^Unison\.Codebase\.Branch\.namespaceStats$''',
'''^Unison\.Codebase\.Branch\.before$''',
'''^Unison\.Codebase\.Branch\.stepEverywhere$''',
'''^Unison\.Codebase\.Branch\.children0$''',
'''^Unison\.Codebase\.BranchUtil\.getBranch$''',
'''^Unison\.Codebase\.BranchUtil\.makeSetBranch$''',
'''^Unison\.Codebase\.Causal\.stepDistinct$''',
'''^Unison\.Codebase\.Causal\.Type\.before$''',
'''^Unison\.Codebase\.CodeLookup\.transitiveDependencies$''',
'''^Unison\.Codebase\.Editor\.DisplayObject\.toMaybe$''',
'''^Unison\.Codebase\.Editor\.DisplayObject\.termDisplayObjectLabeledDependencies$''',
'''^Unison\.Codebase\.Editor\.DisplayObject\.typeDisplayObjectLabeledDependencies$''',
'''^Unison\.Codebase\.Editor\.HandleInput\._searchBranchPrefix$''',
'''^Unison\.Codebase\.Editor\.HandleInput\.SyncV2\.handleSyncFromCodeserver$''',
'''^Unison\.Codebase\.Editor\.HandleInput\.TermResolution\.lookupCon$''',
'''^Unison\.Codebase\.Editor\.HandleInput\.TermResolution\.resolveTerm$''',
'''^Unison\.Codebase\.Editor\.HandleInput\.TermResolution\.resolveCon$''',
'''^Unison\.Codebase\.Editor\.HandleInput\.TermResolution\.resolveTermRef$''',
'''^Unison\.Codebase\.Editor\.RemoteRepo\.printWriteRemoteNamespace$''',
'''^Unison\.Codebase\.Editor\.SlurpComponent\.difference$''',
'''^Unison\.Codebase\.Editor\.SlurpComponent\.intersection$''',
'''^Unison\.Codebase\.Editor\.SlurpResult\.isAllDuplicates$''',
'''^Unison\.Codebase\.Editor\.UriParser\.parseReadShareLooseCode$''',
'''^Unison\.Codebase\.Init\.Type\.DebugName$''',
'''^Unison\.Codebase\.Init\.Type\.Init$''',
'''^Unison\.Codebase\.Init\.initCodebaseAndExit$''',
'''^Unison\.Codebase\.Metadata\.delete$''',
'''^Unison\.Codebase\.Path\.maybePrefix$''',
'''^Unison\.Codebase\.Path\.toAbsoluteSplit$''',
'''^Unison\.Codebase\.Path\.ancestors$''',
'''^Unison\.Codebase\.Path\.unsafeParseText'$''',
'''^Unison\.Codebase\.Path\.Parse\.pathP'$''',
'''^Unison\.Codebase\.Runtime\.Profile\.SomeProfile$''',
'''^Unison\.Codebase\.Serialization\.Format$''',
'''^Unison\.Codebase\.Serialization\.getFromBytes$''',
'''^Unison\.Codebase\.Serialization\.getFromFile$''',
'''^Unison\.Codebase\.Serialization\.getFromFile'$''',
'''^Unison\.Codebase\.Serialization\.putBytes$''',
'''^Unison\.Codebase\.Serialization\.putWithParentDirs$''',
'''^Unison\.Codebase\.ShortCausalHash\.toString$''',
'''^Unison\.Codebase\.ShortCausalHash\.toHash$''',
'''^Unison\.Codebase\.SqliteCodebase\.SyncEphemeral\.Dependencies$''',
'''^Unison\.Codebase\.SqliteCodebase\.copyCodebase$''',
'''^Unison\.Codebase\.SqliteCodebase\.Conversions\.referent2to1UsingCT$''',
'''^Unison\.Codebase\.SqliteCodebase\.Conversions\.constructorType1to2$''',
'''^Unison\.Codebase\.SqliteCodebase\.Conversions\.constructorType2to1$''',
'''^Unison\.Codebase\.SqliteCodebase\.Migrations\.MigrateSchema1To2\._TermReference$''',
'''^Unison\.Codebase\.SqliteCodebase\.Migrations\.MigrateSchema1To2\.DbHelpers\.syncCausalHash$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.prettyBufferEntry$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.addDeclComponentTypeIndex$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.getPatch$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.putPatch$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.patchExists$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.dependentsOfComponentImpl$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.termReferencesByPrefix$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.termExists$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.declExists$''',
'''^Unison\.Codebase\.SqliteCodebase\.Operations\.before$''',
'''^Unison\.Codebase\.TermEdit\.references$''',
'''^Unison\.Codebase\.TermEdit\.toReference$''',
'''^Unison\.Codebase\.TermEdit\.isTypePreserving$''',
'''^Unison\.Codebase\.TermEdit\.isSame$''',
'''^Unison\.Codebase\.TermEdit\.Typing\.typing$''',
'''^Unison\.Codebase\.TypeEdit\.references$''',
'''^Unison\.Codebase\.TypeEdit\.toReference$''',
'''^Unison\.CommandLine\.Completion\.prettyCompletion$''',
'''^Unison\.CommandLine\.Completion\.fixupCompletion$''',
'''^Unison\.CommandLine\.Completion\.completeShareUser$''',
'''^Unison\.CommandLine\.Completion\.completeShareProject$''',
'''^Unison\.CommandLine\.FZFResolvers\.projectBranchWithinCurrentProjectResolver$''',
'''^Unison\.CommandLine\.FZFResolvers\.projectNameResolver$''',
'''^Unison\.CommandLine\.FZFResolvers\.projectBranchOptionsWithinCurrentProject$''',
'''^Unison\.CommandLine\.Helpers\.warnNote$''',
'''^Unison\.CommandLine\.Helpers\.problem$''',
'''^Unison\.CommandLine\.Helpers\.nothingTodo$''',
'''^Unison\.CommandLine\.Helpers\.plural$''',
'''^Unison\.CommandLine\.InputPattern\.minArgs$''',
'''^Unison\.CommandLine\.InputPattern\.suggestionFallbacks$''',
'''^Unison\.CommandLine\.InputPatterns\._handleBranchIdOrProjectArg$''',
'''^Unison\.CommandLine\.InputPatterns\._remoteProjectArg$''',
'''^Unison\.CommandLine\.OutputMessages\.prettyEntityType$''',
'''^Unison\.CommandLine\.OutputMessages\.pushPublicNote$''',
'''^Unison\.CommandLine\.OutputMessages\.noWritePermissionForPath$''',
'''^Unison\.CommandLine\.OutputMessages\.notFastForward$''',
'''^Unison\.CommandLine\.OutputMessages\.filestatusTip$''',
'''^Unison\.DataDeclaration\.constructorCount$''',
'''^Unison\.DataDeclaration\.bindReferences$''',
'''^Unison\.DataDeclaration\.labeledTypeDependencies$''',
'''^Unison\.DataDeclaration\.mkDataDecl'$''',
'''^Unison\.DataDeclaration\.updateDependencies$''',
'''^Unison\.DataDeclaration\.vmap$''',
'''^Unison\.DeclNameLookup\.empty$''',
'''^Unison\.HashQualified\.sortByLength$''',
'''^Unison\.HashQualified\.hasName$''',
'''^Unison\.HashQualified\.hasHash$''',
'''^Unison\.HashQualified\.toStringWith$''',
'''^Unison\.HashQualified\.matchesNamedReferent$''',
'''^Unison\.HashQualified\.matchesNamedReference$''',
'''^Unison\.HashQualifiedPrime\.HQSegment$''',
'''^Unison\.HashQualifiedPrime\.toNameOnly$''',
'''^Unison\.HashQualifiedPrime\.toHash$''',
'''^Unison\.HashQualifiedPrime\.toStringWith$''',
'''^Unison\.HashQualifiedPrime\.fromNameHash$''',
'''^Unison\.HashQualifiedPrime\.searchBySuffix$''',
'''^Unison\.HashQualifiedPrime\.searchUnconflictedBySuffix$''',
'''^Unison\.HashQualifiedPrime\.sortByLength$''',
'''^Unison\.Hashable\.hash$''',
'''^Unison\.Hashing\.V2\.Convert\.m2hPatch$''',
'''^Unison\.Hashing\.V2\.Convert\.hashPatch$''',
'''^Unison\.Hashing\.V2\.Type\.intRef$''',
'''^Unison\.Hashing\.V2\.Type\.natRef$''',
'''^Unison\.Hashing\.V2\.Type\.floatRef$''',
'''^Unison\.Hashing\.V2\.Type\.booleanRef$''',
'''^Unison\.Hashing\.V2\.Type\.textRef$''',
'''^Unison\.Hashing\.V2\.Type\.charRef$''',
'''^Unison\.Hashing\.V2\.Type\.listRef$''',
'''^Unison\.Hashing\.V2\.Type\.effectRef$''',
'''^Unison\.KindInference\.Constraint\.Solved\.prov$''',
'''^Unison\.KindInference\.Constraint\.Solved\.loc$''',
'''^Unison\.KindInference\.Constraint\.TypeProvenance\.prov$''',
'''^Unison\.KindInference\.Generate\.typeConstraints$''',
'''^Unison\.KindInference\.Generate\.Monad\.run$''',
'''^Unison\.LSP\.Conversions\.intervalToRange$''',
'''^Unison\.LSP\.FileAnalysis\.getFileDefLocations$''',
'''^Unison\.LSP\.FileAnalysis\.getFileNames$''',
'''^Unison\.LSP\.HandlerUtils\.cancelRequest$''',
'''^Unison\.LSP\.Queries\.findSmallestEnclosingPattern$''',
'''^Unison\.LSP\.Types\.logInfo$''',
'''^Unison\.LSP\.Types\.logError$''',
'''^Unison\.LSP\.Types\.lspBackend$''',
'''^Unison\.LSP\.Types\.setConfig$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.keyedFromList$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.keyedSingleton$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.keyedSmallestIntersection$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.intersectionsFromList$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.intersectionsSingleton$''',
'''^Unison\.LSP\.Util\.IntersectionMap\.smallestIntersection$''',
'''^Unison\.LabeledDependency\.referents$''',
'''^Unison\.MCP\.Types\.nameKindMapping$''',
'''^Unison\.MCP\.Types\.fromToolName$''',
'''^Unison\.Merge\.DiffOp\.map$''',
'''^Unison\.Merge\.DiffOp\.traverse$''',
'''^Unison\.Merge\.EitherWayI\.excludingAlice$''',
'''^Unison\.Merge\.EitherWayI\.includingAlice$''',
'''^Unison\.Merge\.ThreeWay\.gtoThreeWay$''',
'''^Unison\.Merge\.ThreeWay\.toTwoOrThreeWay$''',
'''^Unison\.Merge\.TwoOrThreeWay\.toThreeWayA$''',
'''^Unison\.Merge\.TwoWay\.fromPair$''',
'''^Unison\.Merge\.TwoWay\.gtoThreeWay$''',
'''^Unison\.Merge\.TwoWay\.unzipMap$''',
'''^Unison\.Merge\.Updated\.bitraverse$''',
'''^Unison\.Merge\.Updated\.foldMap$''',
'''^Unison\.Merge\.Updated\.sequenceDefns$''',
'''^Unison\.Merge\.Updated\.toPair$''',
'''^Unison\.Merge\.Updated\.traverse$''',
'''^Unison\.Merge\.Updated\.unzip$''',
'''^Unison\.Name\.cons$''',
'''^Unison\.Name\.stripReversedPrefix$''',
'''^Unison\.Name\.tryStripReversedPrefix$''',
'''^Unison\.Name\.isPrefixOf$''',
'''^Unison\.Name\.searchUnconflictedBySuffix$''',
'''^Unison\.Name\.sortNames$''',
'''^Unison\.Names\.makeRelative$''',
'''^Unison\.Names\.referenceIds$''',
'''^Unison\.Names\.termReferents$''',
'''^Unison\.Names\.restrictReferences$''',
'''^Unison\.Names\.refTermsHQNamed$''',
'''^Unison\.Names\.addType$''',
'''^Unison\.Names\.addTerm$''',
'''^Unison\.Names\.fromTerms$''',
'''^Unison\.Names\.fromTypes$''',
'''^Unison\.Names\.fromTermsAndTypes$''',
'''^Unison\.Names\.filterBySHs$''',
'''^Unison\.Names\.filterTypes$''',
'''^Unison\.Names\.contains$''',
'''^Unison\.Names\.constructorsForType$''',
'''^Unison\.Names\.ResolutionResult\.getName$''',
'''^Unison\.NamesWithHistory\.push$''',
'''^Unison\.NamesWithHistory\.lookupHQType'$''',
'''^Unison\.NamesWithHistory\.hasTermNamed$''',
'''^Unison\.NamesWithHistory\.lookupHQTerm'$''',
'''^Unison\.Parsers\.readAndParseFile$''',
'''^Unison\.Parsers\.unsafeParseTerm$''',
'''^Unison\.Parsers\.unsafeReadAndParseFile$''',
'''^Unison\.Parsers\.unsafeParseFileBuiltinsOnly$''',
'''^Unison\.Pattern\.application$''',
'''^Unison\.Pattern\.setLoc$''',
'''^Unison\.Pattern\.labeledDependencies$''',
'''^Unison\.PatternMatchCoverage\.IntervalSet\.member$''',
'''^Unison\.PatternMatchCoverage\.IntervalSet\.foldr$''',
'''^Unison\.PatternMatchCoverage\.IntervalSet\.map$''',
'''^Unison\.PatternMatchCoverage\.IntervalSet\.intersection$''',
'''^Unison\.PatternMatchCoverage\.IntervalSet\.extractSingleton$''',
'''^Unison\.PatternMatchCoverage\.ListPat\.prettyListPat$''',
'''^Unison\.PatternMatchCoverage\.Literal\.prettyLiteral$''',
'''^Unison\.Prelude\.onFalse$''',
'''^Unison\.Prelude\.onFalseM$''',
'''^Unison\.Prelude\.eitherToThese$''',
'''^Unison\.Prelude\.wundefined$''',
'''^Unison\.PrettyTerminal\.stripSurroundingBlanks$''',
'''^Unison\.PrintError\._posToEnglish$''',
'''^Unison\.PrintError\._printPosRange$''',
'''^Unison\.PrintError\._printArrowsAtPos$''',
'''^Unison\.Project\.projectBranchNameUserSlug$''',
'''^Unison\.Reference\.Size$''',
'''^Unison\.Reference\.toHash$''',
'''^Unison\.Reference\.component$''',
'''^Unison\.Reference\.components$''',
'''^Unison\.Reference\.groupByComponent$''',
'''^Unison\.Referent\.toId$''',
'''^Unison\.Referent\.fromId$''',
'''^Unison\.Referent\.toString$''',
'''^Unison\.Referent\.toReferenceId$''',
'''^Unison\.Referent\.fold$''',
'''^Unison\.ReferentPrime\.toTermReference$''',
'''^Unison\.ReferentPrime\.fold$''',
'''^Unison\.Result\.isSuccess$''',
'''^Unison\.Result\.isFailure$''',
'''^Unison\.Result\.toMaybe$''',
'''^Unison\.Result\.getResult$''',
'''^Unison\.Result\.toEither$''',
'''^Unison\.Runtime\.ANF\.Serialize\.BDeserial$''',
'''^Unison\.Runtime\.ANF\.Serialize\.SDeserial$''',
'''^Unison\.Runtime\.ANF\.minimizeCyclesOrCrash$''',
'''^Unison\.Runtime\.ANF\.unbind$''',
'''^Unison\.Runtime\.ANF\.litRef$''',
'''^Unison\.Runtime\.ANF\.overGroup$''',
'''^Unison\.Runtime\.ANF\.traverseGroup$''',
'''^Unison\.Runtime\.ANF\.MurmurHash\.Untyped\.hash64AddTermRefs$''',
'''^Unison\.Runtime\.ANF\.MurmurHash\.Untyped\.hash64AddAssoc$''',
'''^Unison\.Runtime\.Array\.checkIMPArray$''',
'''^Unison\.Runtime\.Array\.checkWMPArray$''',
'''^Unison\.Runtime\.Array\.readPrimArray$''',
'''^Unison\.Runtime\.Array\.writePrimArray$''',
'''^Unison\.Runtime\.Builtin\.builtinForeignNames$''',
'''^Unison\.Runtime\.Canonicalizer\.unsafeCategorize$''',
'''^Unison\.Runtime\.Canonicalizer\.canonicalize0$''',
'''^Unison\.Runtime\.Canonicalizer\.canonicalize$''',
'''^Unison\.Runtime\.Canonicalizer\.findWithDefault0$''',
'''^Unison\.Runtime\.Canonicalizer\.findWithDefault$''',
'''^Unison\.Runtime\.Canonicalizer\.unsafeLookup$''',
'''^Unison\.Runtime\.Canonicalizer\.fromListByIndex$''',
'''^Unison\.Runtime\.Canonicalizer\.fromList$''',
'''^Unison\.Runtime\.Foreign\.unwrapBuiltin$''',
'''^Unison\.Runtime\.IOSource\.TFile$''',
'''^Unison\.Runtime\.IOSource\.SynthResult$''',
'''^Unison\.Runtime\.IOSource\.EitherResult$''',
'''^Unison\.Runtime\.IOSource\.abilityNamedId$''',
'''^Unison\.Runtime\.IOSource\.eitherReference$''',
'''^Unison\.Runtime\.IOSource\.optionReference$''',
'''^Unison\.Runtime\.IOSource\.isTestReference$''',
'''^Unison\.Runtime\.IOSource\.isPropagatedReference$''',
'''^Unison\.Runtime\.IOSource\.isTest$''',
'''^Unison\.Runtime\.IOSource\.isIOTest$''',
'''^Unison\.Runtime\.IOSource\.isPropagatedValue$''',
'''^Unison\.Runtime\.IOSource\.eitherLeftId$''',
'''^Unison\.Runtime\.IOSource\.eitherRightId$''',
'''^Unison\.Runtime\.IOSource\.someId$''',
'''^Unison\.Runtime\.IOSource\.noneId$''',
'''^Unison\.Runtime\.IOSource\.doc2TermRef$''',
'''^Unison\.Runtime\.IOSource\.prettyRef$''',
'''^Unison\.Runtime\.IOSource\.constructorName$''',
'''^Unison\.Runtime\.MCode\.RCombInfo$''',
'''^Unison\.Runtime\.MCode\.argsToLists$''',
'''^Unison\.Runtime\.MCode\.combDeps$''',
'''^Unison\.Runtime\.MCode\.sectionDeps$''',
'''^Unison\.Runtime\.MCode\.branchDeps$''',
'''^Unison\.Runtime\.MCode\.indent$''',
'''^Unison\.Runtime\.MCode\.prettyCombs$''',
'''^Unison\.Runtime\.MCode\.prettyComb$''',
'''^Unison\.Runtime\.MCode\.prettySection$''',
'''^Unison\.Runtime\.MCode\.prettyCIx$''',
'''^Unison\.Runtime\.MCode\.prettyRef$''',
'''^Unison\.Runtime\.MCode\.prettyGRef$''',
'''^Unison\.Runtime\.MCode\.prettyBranches$''',
'''^Unison\.Runtime\.MCode\.prettyIns$''',
'''^Unison\.Runtime\.MCode\.prettyArgs$''',
'''^Unison\.Runtime\.Machine\.Primops\.termLinkVal$''',
'''^Unison\.Runtime\.Machine\.Primops\.typeLinkVal$''',
'''^Unison\.Runtime\.Serialize\.putBool$''',
'''^Unison\.Runtime\.Serialize\.getBool$''',
'''^Unison\.Runtime\.Serialize\.getArray$''',
'''^Unison\.Runtime\.Serialize\.putArray$''',
'''^Unison\.Runtime\.Serialize\.putReferentByNumber$''',
'''^Unison\.Runtime\.Serialize\.getReferentByNumber$''',
'''^Unison\.Runtime\.Serialize\.putConstructorReferenceByNumber$''',
'''^Unison\.Runtime\.Serialize\.getConstructorReferenceByNumber$''',
'''^Unison\.Runtime\.Serialize\.putReferenceByNumber$''',
'''^Unison\.Runtime\.Serialize\.getReferenceByNumber$''',
'''^Unison\.Runtime\.Serialize\.lookupRef$''',
'''^Unison\.Runtime\.ANF\.Serialize\.DeserialIO$''',
'''^Unison\.Runtime\.ANF\.Serialize\.DeserialST$''',
'''^Unison\.Runtime\.Serialize\.Get\.getWord64le$''',
'''^Unison\.Runtime\.Serialize\.Get\.getFloatbe$''',
'''^Unison\.Runtime\.Serialize\.Get\.evaluated$''',
'''^Unison\.Runtime\.Serialize\.Get\.getPrimArray$''',
'''^Unison\.Runtime\.SparseVector\.map$''',
'''^Unison\.Runtime\.SparseVector\.mask$''',
'''^Unison\.Runtime\.SparseVector\.zipWith$''',
'''^Unison\.Runtime\.SparseVector\._1$''',
'''^Unison\.Runtime\.SparseVector\._2$''',
'''^Unison\.Runtime\.SparseVector\.unzip$''',
'''^Unison\.Runtime\.SparseVector\.choose$''',
'''^Unison\.Runtime\.SparseVector\.merge$''',
'''^Unison\.Runtime\.SparseVector\.eq$''',
'''^Unison\.Runtime\.Stack\.IxClosure$''',
'''^Unison\.Runtime\.Stack\.FP$''',
'''^Unison\.Runtime\.Stack\.xStackIOToIO$''',
'''^Unison\.Runtime\.Stack\.stackIOToIOX$''',
'''^Unison\.Runtime\.Stack\.peekI$''',
'''^Unison\.Runtime\.Stack\.upeek$''',
'''^Unison\.Runtime\.Stack\.peekTag$''',
'''^Unison\.Runtime\.Stack\.peekTagOff$''',
'''^Unison\.Runtime\.Stack\.upokeOffT$''',
'''^Unison\.Runtime\.Stack\.duplicate$''',
'''^Unison\.Runtime\.Stack\.peekN$''',
'''^Unison\.Runtime\.Stack\.peekD$''',
'''^Unison\.Runtime\.Stack\.peekC$''',
'''^Unison\.Runtime\.Stack\.pokeByte$''',
'''^Unison\.Runtime\.Stack\.pokeOffN$''',
'''^Unison\.Runtime\.Stack\.pokeOffD$''',
'''^Unison\.Runtime\.Stack\.pokeOffI$''',
'''^Unison\.Runtime\.Stack\.pokeOffC$''',
'''^Unison\.Runtime\.Stack\.peekBi$''',
'''^Unison\.Runtime\.Stack\.peekBool$''',
'''^Unison\.Runtime\.Stack\.frameView$''',
'''^Unison\.Runtime\.Stack\.hasNoAllocations$''',
'''^Unison\.Runtime\.Stack\.inflateMap$''',
'''^Unison\.Runtime\.Stack\.deflateMap$''',
'''^Unison\.Runtime\.TypeTags\.floatTag$''',
'''^Unison\.Runtime\.TypeTags\.charTag$''',
'''^Unison\.Runtime\.TypeTags\.avroLogicalStringUUIDTag$''',
'''^Unison\.Runtime\.Vector\.mu$''',
'''^Unison\.Runtime\.Vector\.bound$''',
'''^Unison\.Runtime\.Vector\.toList$''',
'''^Unison\.Server\.Backend\.termEntryLabeledDependencies$''',
'''^Unison\.Server\.Backend\.typeEntryLabeledDependencies$''',
'''^Unison\.Server\.Backend\.isTestResultList$''',
'''^Unison\.Server\.Backend\.resultListType$''',
'''^Unison\.Server\.Backend\.fixupNamesRelative$''',
'''^Unison\.Server\.Backend\.definitionResultsDependencies$''',
'''^Unison\.Server\.Backend\.getShallowCausalAtPathFromRootHash$''',
'''^Unison\.Server\.Backend\.resolveRootBranchHash$''',
'''^Unison\.Server\.CodebaseServer\.unisonAndDocsAPI$''',
'''^Unison\.Server\.Doc\.evalAndRenderDoc$''',
'''^Unison\.Server\.Doc\.dependencies$''',
'''^Unison\.Server\.Doc\.dependenciesSpecial$''',
'''^Unison\.Server\.Errors\.badHQN$''',
'''^Unison\.Server\.NameSearch\.hoistSearch$''',
'''^Unison\.Server\.NameSearch\.hoistNameSearch$''',
'''^Unison\.Server\.Orphans\.encodeVectorWith$''',
'''^Unison\.Server\.SearchResult\.aliases$''',
'''^Unison\.Server\.SearchResult\.truncateAliases$''',
'''^Unison\.Server\.SearchResult\._fromNames$''',
'''^Unison\.Server\.SearchResultPrime\.tmReferent$''',
'''^Unison\.Server\.SearchResultPrime\.tpReference$''',
'''^Unison\.Server\.SearchResultPrime\.labeledDependencies$''',
'''^Unison\.Server\.Syntax\.syntax$''',
'''^Unison\.Server\.Types\.NamespaceFQN$''',
'''^Unison\.Server\.Types\.Size$''',
'''^Unison\.Server\.Types\.exactToHQ$''',
'''^Unison\.Server\.Types\.exactToHQ'$''',
'''^Unison\.Server\.Types\.unisonRefToText$''',
'''^Unison\.Server\.Types\.discard$''',
'''^Unison\.Server\.Types\.branchToUnisonHash$''',
'''^Unison\.Settings\.renderTermMaxLength$''',
'''^Unison\.Settings\.demoHideVarNumber$''',
'''^Unison\.Share\.SyncV2\._unNetString$''',
'''^Unison\.Share\.SyncV2\._decodeFramedEntity$''',
'''^Unison\.Sqlite\.Connection\.queryStreamRow$''',
'''^Unison\.Sqlite\.Connection\.queryStreamCol$''',
'''^Unison\.Sqlite\.Connection\.queryListColCheck$''',
'''^Unison\.Sqlite\.Connection\.withSavepoint$''',
'''^Unison\.Sqlite\.Connection\.withSavepointIO$''',
'''^Unison\.Sqlite\.Connection\.savepoint$''',
'''^Unison\.Sqlite\.Connection\.rollbackTo$''',
'''^Unison\.Sqlite\.Connection\.release$''',
'''^Unison\.Sqlite\.Connection\.executeStatements$''',
'''^Unison\.Sqlite\.Connection\.queryMaybeColCheck$''',
'''^Unison\.Sqlite\.Connection\.rowsModified$''',
'''^Unison\.Sqlite\.DataVersion\.getDataVersion$''',
'''^Unison\.Sqlite\.Exception\.isCantOpenException$''',
'''^Unison\.Sqlite\.Sql\.sql$''',
'''^Unison\.Sqlite\.Sql\.sqlQQ$''',
'''^Unison\.Sqlite\.Sql\.inSql$''',
'''^Unison\.Sqlite\.Transaction\.unTransactionWithMonadIO$''',
'''^Unison\.Sqlite\.Transaction\.runReadOnlyTransaction$''',
'''^Unison\.Sqlite\.Transaction\.runReadOnlyTransaction_$''',
'''^Unison\.Sqlite\.Transaction\.cacheTransaction$''',
'''^Unison\.Sqlite\.Transaction\.savepoint$''',
'''^Unison\.Sqlite\.Transaction\.queryStreamRow$''',
'''^Unison\.Sqlite\.Transaction\.queryStreamCol$''',
'''^Unison\.Sqlite\.Transaction\.queryListRowCheck$''',
'''^Unison\.Sqlite\.Transaction\.queryListColCheck$''',
'''^Unison\.Sqlite\.Transaction\.queryMaybeRowCheck$''',
'''^Unison\.Sqlite\.Transaction\.time$''',
'''^Unison\.Sqlite\.Transaction\.executeStatements$''',
'''^Unison\.Sqlite\.Transaction\.queryMaybeRow$''',
'''^Unison\.Sqlite\.Transaction\.queryOneRow$''',
'''^Unison\.Sqlite\.Transaction\.queryMaybeColCheck$''',
'''^Unison\.Sqlite\.Transaction\.queryOneRowCheck$''',
'''^Unison\.Sqlite\.Transaction\.rowsModified$''',
'''^Unison\.Sync\.API\.api$''',
'''^Unison\.Sync\.Types\.pathCodebasePath$''',
'''^Unison\.Sync\.Types\.patchOldHashes_$''',
'''^Unison\.SyncV2\.API\.api$''',
'''^Unison\.Syntax\.Lexer\.Unison\.debugFilePreParse$''',
'''^Unison\.Syntax\.NamePrinter\.prettyLabeledDependency$''',
'''^Unison\.Syntax\.Parser\.wordyPatternName$''',
'''^Unison\.Syntax\.TermPrinter\.prettyBinding'$''',
'''^Unison\.Syntax\.TypePrinter\.prettySignaturesAlt'$''',
'''^Unison\.Syntax\.TypePrinter\.prettySignaturesAlt$''',
'''^Unison\.Term\.vmap$''',
'''^Unison\.Term\.wrapV$''',
'''^Unison\.Term\.allVars$''',
'''^Unison\.Term\.freeTypeVars$''',
'''^Unison\.Term\.fresh$''',
'''^Unison\.Term\.var'$''',
'''^Unison\.Term\.watch$''',
'''^Unison\.Term\.watchMaybe$''',
'''^Unison\.Term\.placeholder$''',
'''^Unison\.Term\.app_$''',
'''^Unison\.Term\.ann_$''',
'''^Unison\.Term\.letRec_$''',
'''^Unison\.Term\.unLetRec$''',
'''^Unison\.Term\.unAnds$''',
'''^Unison\.Term\.unOrs$''',
'''^Unison\.Term\.unOverappliedBinaryAppPred$''',
'''^Unison\.Term\.unBinaryApps$''',
'''^Unison\.Term\.unBinaryAppsPred$''',
'''^Unison\.Term\.constructorDependencies$''',
'''^Unison\.Term\.betaReduce$''',
'''^Unison\.Term\.betaNormalForm$''',
'''^Unison\.Term\.containsExpression$''',
'''^Unison\.Type\.wrapV$''',
'''^Unison\.Type\.bindReferences$''',
'''^Unison\.Type\.unPure$''',
'''^Unison\.Type\.isArrow$''',
'''^Unison\.Type\.derivedBase32Hex$''',
'''^Unison\.Type\.integer$''',
'''^Unison\.Type\.natural$''',
'''^Unison\.Type\.iff$''',
'''^Unison\.Type\.iff'$''',
'''^Unison\.Type\.andor$''',
'''^Unison\.Type\.v'$''',
'''^Unison\.Type\.forAll'$''',
'''^Unison\.Type\.flipApply$''',
'''^Unison\.Type\.unforall$''',
'''^Unison\.Type\.usesEffects$''',
'''^Unison\.Type\.functionResult$''',
'''^Unison\.Typechecker\.Name$''',
'''^Unison\.Typechecker\.check$''',
'''^Unison\.Typechecker\.wellTyped$''',
'''^Unison\.Typechecker\.Context\._logContext$''',
'''^Unison\.Typechecker\.Context\.isEqual$''',
'''^Unison\.Typechecker\.Extractor\.traceSubseq$''',
'''^Unison\.Typechecker\.Extractor\.traceNote$''',
'''^Unison\.Typechecker\.Extractor\._no$''',
'''^Unison\.Typechecker\.Extractor\._any$''',
'''^Unison\.Typechecker\.Extractor\._any'$''',
'''^Unison\.Typechecker\.Extractor\.inSynthesize$''',
'''^Unison\.Typechecker\.Extractor\.inEquate$''',
'''^Unison\.Typechecker\.Extractor\.illFormedType$''',
'''^Unison\.Typechecker\.Extractor\.effectConstructorWrongArgCount$''',
'''^Unison\.Typechecker\.Extractor\.malformedEffectBind$''',
'''^Unison\.Typechecker\.Extractor\.solvedBlank$''',
'''^Unison\.Typechecker\.Extractor\.infoNote$''',
'''^Unison\.Typechecker\.Extractor\.topLevelComponent$''',
'''^Unison\.Typechecker\.TypeError\.TypeNote$''',
'''^Unison\.Typechecker\.TypeError\.topLevelComponent$''',
'''^Unison\.Typechecker\.TypeLookup\.unsafeConstructorType$''',
'''^Unison\.Typechecker\.TypeLookup\.constructorType$''',
'''^Unison\.UnisonFile\.emptyUnisonFile$''',
'''^Unison\.UnisonFile\.leftBiasedMerge$''',
'''^Unison\.UnisonFile\.termSignatureExternalLabeledDependencies$''',
'''^Unison\.UnisonFile\.nonEmpty$''',
'''^Unison\.Util\.Alternative\.whenM$''',
'''^Unison\.Util\.AnnotatedText\.deannotate$''',
'''^Unison\.Util\.AnnotatedText\.trailingNewLine$''',
'''^Unison\.Util\.AnnotatedText\.textLength$''',
'''^Unison\.Util\.AnnotatedText\.textEmpty$''',
'''^Unison\.Util\.Bytes\.null$''',
'''^Unison\.Util\.Bytes\.isAscii$''',
'''^Unison\.Util\.Bytes\.chunkSize$''',
'''^Unison\.Util\.Bytes\.cons$''',
'''^Unison\.Util\.Bytes\.index$''',
'''^Unison\.Util\.Bytes\.arrayFromChunk$''',
'''^Unison\.Util\.ColorText\.unstyled$''',
'''^Unison\.Util\.ColorText\.toHTML$''',
'''^Unison\.Util\.CycleTable\.new$''',
'''^Unison\.Util\.CycleTable\.lookup$''',
'''^Unison\.Util\.CycleTable\.insert$''',
'''^Unison\.Util\.CycleTable\.size$''',
'''^Unison\.Util\.CycleTable\.insertEnd$''',
'''^Unison\.Util\.CyclicEq\.bothEq'$''',
'''^Unison\.Util\.CyclicOrd\.bothOrd'$''',
'''^Unison\.Util\.Defns\.DefnsF4$''',
'''^Unison\.Util\.Defns\.terms_$''',
'''^Unison\.Util\.Defns\.types_$''',
'''^Unison\.Util\.Defns\.hoistDefnsF$''',
'''^Unison\.Util\.Defns\.mapDefns$''',
'''^Unison\.Util\.Defns\.zipDefns$''',
'''^Unison\.Util\.EnumContainers\.intersectionWith$''',
'''^Unison\.Util\.EnumContainers\.hasKey$''',
'''^Unison\.Util\.EnumContainers\.traverseSet_$''',
'''^Unison\.Util\.EnumContainers\.traverseWithKey$''',
'''^Unison\.Util\.Exception\.tryAny$''',
'''^Unison\.Util\.Exception\.catchAny$''',
'''^Unison\.Util\.Find\.fuzzyFinder$''',
'''^Unison\.Util\.Find\.simpleFuzzyFinder$''',
'''^Unison\.Util\.Find\.highlightSimple$''',
'''^Unison\.Util\.Find\.fuzzyFindMatchArray$''',
'''^Unison\.Util\.Find\.prefixFindInBranch$''',
'''^Unison\.Util\.Find\.fuzzyFindInBranch$''',
'''^Unison\.Util\.Find\.getName$''',
'''^Unison\.Util\.Find\.candidates$''',
'''^Unison\.Util\.Find\.highlight$''',
'''^Unison\.Util\.Find\.highlight'$''',
'''^Unison\.Util\.Lens\.Field1'$''',
'''^Unison\.Util\.Lens\.Field2'$''',
'''^Unison\.Util\.Lens\.Field3'$''',
'''^Unison\.Util\.Lens\.Field4'$''',
'''^Unison\.Util\.List\.intercalateMapWith$''',
'''^Unison\.Util\.List\.quenchRuns$''',
'''^Unison\.Util\.Map\.alignWithKey$''',
'''^Unison\.Util\.Map\.insertLookup$''',
'''^Unison\.Util\.Map\.invert$''',
'''^Unison\.Util\.Map\.upsertLookup$''',
'''^Unison\.Util\.Map\.foldKeysCommutative$''',
'''^Unison\.Util\.Map\.foldValuesCommutative$''',
'''^Unison\.Util\.Map\.foldM$''',
'''^Unison\.Util\.Map\.for_$''',
'''^Unison\.Util\.Map\.fromSetA$''',
'''^Unison\.Util\.Map\.remap$''',
'''^Unison\.Util\.Map\.traverseKeysWith$''',
'''^Unison\.Util\.Map\.bitraversed$''',
'''^Unison\.Util\.Map\.swap$''',
'''^Unison\.Util\.Map\.valuesVector$''',
'''^Unison\.Util\.Map\.traverseKeys$''',
'''^Unison\.Util\.Monoid\.isEmpty$''',
'''^Unison\.Util\.Monoid\.nonEmpty$''',
'''^Unison\.Util\.Nametree\.traverseNametreeWithName$''',
'''^Unison\.Util\.Nametree\.flattenNametree$''',
'''^Unison\.Util\.Nametree\.flattenNametrees$''',
'''^Unison\.Util\.Pretty\.orElses$''',
'''^Unison\.Util\.Pretty\.toHTML$''',
'''^Unison\.Util\.Pretty\.oxfordCommas$''',
'''^Unison\.Util\.Pretty\.sepSpaced$''',
'''^Unison\.Util\.Pretty\.excerptSep$''',
'''^Unison\.Util\.Pretty\.commented$''',
'''^Unison\.Util\.Pretty\.numberedHeader$''',
'''^Unison\.Util\.Pretty\.numberedColumn2Header$''',
'''^Unison\.Util\.Pretty\.leftPad$''',
'''^Unison\.Util\.Pretty\.excerptColumn2Headed$''',
'''^Unison\.Util\.Pretty\.excerptColumn2$''',
'''^Unison\.Util\.Pretty\.column3M$''',
'''^Unison\.Util\.Pretty\.column3UnzippedM$''',
'''^Unison\.Util\.Pretty\.softHangNoSpace'$''',
'''^Unison\.Util\.Pretty\.hangUngrouped'$''',
'''^Unison\.Util\.Pretty\.hangUngrouped$''',
'''^Unison\.Util\.Pretty\.nest$''',
'''^Unison\.Util\.Pretty\.plural$''',
'''^Unison\.Util\.Pretty\.boxForkLeft$''',
'''^Unison\.Util\.Pretty\.lBoxStyle1$''',
'''^Unison\.Util\.Pretty\.boxLeftM$''',
'''^Unison\.Util\.Pretty\.boxRightM$''',
'''^Unison\.Util\.Range\.isMultiLine$''',
'''^Unison\.Util\.Recursion\.para$''',
'''^Unison\.Util\.Servant\.CBOR\.decodeCBORBytes$''',
'''^Unison\.Util\.Set\.insertMaybe$''',
'''^Unison\.Util\.Set\.symmetricDifference$''',
'''^Unison\.Util\.Set\.filterM$''',
'''^Unison\.Util\.Set\.flatMap$''',
'''^Unison\.Util\.Set\.for$''',
'''^Unison\.Util\.Set\.forMaybe$''',
'''^Unison\.Util\.Set\.thenInsert$''',
'''^Unison\.Util\.Set\.thenInsertMaybe$''',
'''^Unison\.Util\.Set\.unalignWith$''',
'''^Unison\.Util\.Set\.unzipWith$''',
'''^Unison\.Util\.Star2\.mapD2$''',
'''^Unison\.Util\.Star2\.empty$''',
'''^Unison\.Util\.Star2\.deleteD2$''',
'''^Unison\.Util\.Star2\.garbageCollect$''',
'''^Unison\.Util\.Star2\.deleteFact$''',
'''^Unison\.Util\.Star2\.replaceFacts$''',
'''^Unison\.Util\.Star2\.replaceFact$''',
'''^Unison\.Util\.TQueue\.size$''',
'''^Unison\.Util\.TQueue\.awaitSize$''',
'''^Unison\.Util\.TQueue\.peek$''',
'''^Unison\.Util\.TQueue\.dequeue$''',
'''^Unison\.Util\.TQueue\.dequeueN$''',
'''^Unison\.Util\.TQueue\.enqueueCount$''',
'''^Unison\.Util\.TQueue\.raceIO$''',
'''^Unison\.Util\.TQueue\.tryPeekWhile$''',
'''^Unison\.Util\.TQueue\.takeWhile$''',
'''^Unison\.Util\.TQueue\.peekWhile$''',
'''^Unison\.Util\.Text\.unsnocChunk$''',
'''^Unison\.Util\.Text\.Pattern\.charNotInPred$''',
'''^Unison\.Util\.TransitiveClosure\.transitiveClosure$''',
'''^Unison\.Util\.TransitiveClosure\.transitiveClosure'$''',
'''^Unison\.Util\.TransitiveClosure\.transitiveClosure1$''',
'''^Unison\.Util\.TransitiveClosure\.transitiveClosure1'$''',
'''^Unison\.Test\.CodebaseInit\.writeTranscriptOutput$''',
'''^Unison\.Test\.ColorText\.ex4e$''',
'''^Unison\.Test\.ColorText\.ex4t$''',
'''^Unison\.Test\.ColorText\.ex2$''',
'''^Unison\.Test\.ColorText\.renderEx2$''',
'''^Unison\.Test\.ColorText\.ex3$''',
'''^Unison\.Test\.ColorText\.ex4$''',
'''^Unison\.Test\.ColorText\.ex$''',
'''^Unison\.Test\.Runtime\.ANF\.simpleRefs$''',
'''^Unison\.Test\.Runtime\.ANF\.denormalizeRef$''',
'''^Unison\.Test\.Runtime\.ANF\.backReference$''',
'''^Unison\.Test\.Runtime\.MCode\.dummyRef$''',
'''^Unison\.Test\.Runtime\.MCode\.modifyTVarTest$''',
'''^Unison\.Test\.Syntax\.FileParser\.test2$''',
'''^Unison\.Test\.Syntax\.TypePrinter\.tc_breaks$''',
'''^Unison\.Test\.Typechecker\.Components\.test$''',
'''^Unison\.Test\.Ucm\.deleteCodebase$''',
'''^Unison\.Test\.UriParser\.mkPath$''',
'''^Unison\.Test\.UriParser\.sch$''',
'''^Unison\.Auth\.PersonalKey\.publicKey$''',
'''^Unison\.Auth\.PersonalKey\.verifyWithPersonalKey$''',
]
type-class-roots = true
unused-types = true