weeder.toml

### 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