packages feed

hydra 0.17.7 → 0.18.0

raw patch · 3 files changed

+84/−4 lines, 3 filesdep ~hydra-haskelldep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-haskell, hydra-kernel

API changes (from Hackage documentation)

+ Hydra: Adapter :: Bool -> t1 -> t2 -> Coder v1 v2 e -> Adapter t1 t2 v1 v2 e
+ Hydra: AdapterContext :: Graph -> Language -> Map Name (Adapter Type Type Term Term Error) -> AdapterContext
+ Hydra: AnnotatedTerm :: Term -> Term -> AnnotatedTerm
+ Hydra: AnnotatedType :: Type -> Term -> AnnotatedType
+ Hydra: Application :: Term -> Term -> Application
+ Hydra: ApplicationType :: Type -> Type -> ApplicationType
+ Hydra: Bicoder :: (t1 -> Adapter t1 t2 v1 v2 e) -> (t2 -> Adapter t2 t1 v2 v1 e) -> Bicoder t1 t2 v1 v2 e
+ Hydra: Binding :: Name -> Term -> Maybe TypeScheme -> Binding
+ Hydra: CaseAlternative :: Name -> Term -> CaseAlternative
+ Hydra: CaseConventionCamel :: CaseConvention
+ Hydra: CaseConventionLowerSnake :: CaseConvention
+ Hydra: CaseConventionPascal :: CaseConvention
+ Hydra: CaseConventionUpperDashed :: CaseConvention
+ Hydra: CaseConventionUpperSnake :: CaseConvention
+ Hydra: CaseConventions :: CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConvention -> CaseConventions
+ Hydra: CaseStatement :: Name -> Maybe Term -> [CaseAlternative] -> CaseStatement
+ Hydra: CheckingErrorIncorrectUnification :: IncorrectUnificationError -> CheckingError
+ Hydra: CheckingErrorNotAForallType :: NotAForallTypeError -> CheckingError
+ Hydra: CheckingErrorNotAFunctionType :: NotAFunctionTypeError -> CheckingError
+ Hydra: CheckingErrorOther :: OtherCheckingError -> CheckingError
+ Hydra: CheckingErrorTypeArityMismatch :: TypeArityMismatchError -> CheckingError
+ Hydra: CheckingErrorTypeMismatch :: TypeMismatchError -> CheckingError
+ Hydra: CheckingErrorUnboundTypeVariables :: UnboundTypeVariablesError -> CheckingError
+ Hydra: CheckingErrorUndefinedTermVariable :: UndefinedTermVariableCheckingError -> CheckingError
+ Hydra: CheckingErrorUnequalTypes :: UnequalTypesError -> CheckingError
+ Hydra: CheckingErrorUnsupportedTermVariant :: UnsupportedTermVariantError -> CheckingError
+ Hydra: CheckingErrorUntypedLambda :: UntypedLambdaError -> CheckingError
+ Hydra: CheckingErrorUntypedLetBinding :: UntypedLetBindingError -> CheckingError
+ Hydra: CheckingErrorUntypedTermVariable :: UntypedTermVariableCheckingError -> CheckingError
+ Hydra: Coder :: (v1 -> Either e v2) -> (v2 -> Either e v1) -> Coder v1 v2 e
+ Hydra: CoderDirectionDecode :: CoderDirection
+ Hydra: CoderDirectionEncode :: CoderDirection
+ Hydra: ColumnName :: String -> ColumnName
+ Hydra: ColumnSchema :: ColumnName -> t -> ColumnSchema t
+ Hydra: ColumnType :: ColumnName -> Type -> ColumnType
+ Hydra: ComparisonConstraintEqual :: ComparisonConstraint
+ Hydra: ComparisonConstraintGreaterThan :: ComparisonConstraint
+ Hydra: ComparisonConstraintGreaterThanOrEqual :: ComparisonConstraint
+ Hydra: ComparisonConstraintLessThan :: ComparisonConstraint
+ Hydra: ComparisonConstraintLessThanOrEqual :: ComparisonConstraint
+ Hydra: ComparisonConstraintNotEqual :: ComparisonConstraint
+ Hydra: ComparisonEqualTo :: Comparison
+ Hydra: ComparisonGreaterThan :: Comparison
+ Hydra: ComparisonLessThan :: Comparison
+ Hydra: ConstantConditionError :: SubtermPath -> Bool -> ConstantConditionError
+ Hydra: DataRow :: [Maybe v] -> DataRow v
+ Hydra: DecodingError :: String -> DecodingError
+ Hydra: DefinitionPrimitive :: PrimitiveDefinition -> Definition
+ Hydra: DefinitionReferencePrimitive :: Name -> DefinitionReference
+ Hydra: DefinitionReferenceTerm :: Name -> DefinitionReference
+ Hydra: DefinitionReferenceType :: Name -> DefinitionReference
+ Hydra: DefinitionTerm :: TermDefinition -> Definition
+ Hydra: DefinitionType :: TypeDefinition -> Definition
+ Hydra: DependencyScopeApi :: DependencyScope
+ Hydra: DependencyScopeRuntime :: DependencyScope
+ Hydra: DependencyScopeTest :: DependencyScope
+ Hydra: DependencyScopeTool :: DependencyScope
+ Hydra: DuplicateBindingError :: SubtermPath -> Name -> DuplicateBindingError
+ Hydra: DuplicateFieldError :: SubtermPath -> Name -> DuplicateFieldError
+ Hydra: DuplicateRecordTypeFieldNamesError :: SubtermPath -> Name -> DuplicateRecordTypeFieldNamesError
+ Hydra: DuplicateUnionTypeFieldNamesError :: SubtermPath -> Name -> DuplicateUnionTypeFieldNamesError
+ Hydra: Edge :: Name -> Maybe Name -> Maybe Name -> Edge
+ Hydra: EffectfulTestCase :: (() -> IO String) -> (() -> String) -> EffectfulTestCase
+ Hydra: EitherType :: Type -> Type -> EitherType
+ Hydra: EmptyCaseStatementError :: SubtermPath -> Name -> EmptyCaseStatementError
+ Hydra: EmptyLetBindingsError :: SubtermPath -> EmptyLetBindingsError
+ Hydra: EmptyRecordTypeError :: SubtermPath -> EmptyRecordTypeError
+ Hydra: EmptyTermAnnotationError :: SubtermPath -> EmptyTermAnnotationError
+ Hydra: EmptyTypeAnnotationError :: SubtermPath -> EmptyTypeAnnotationError
+ Hydra: EmptyTypeNameInTermError :: SubtermPath -> EmptyTypeNameInTermError
+ Hydra: EmptyUnionTypeError :: SubtermPath -> EmptyUnionTypeError
+ Hydra: EntityMetadata :: Maybe String -> [String] -> [EntityReference] -> Maybe LifecycleInfo -> [Provision] -> EntityMetadata
+ Hydra: EntityReferenceDefinition :: DefinitionReference -> EntityReference
+ Hydra: EntityReferenceModule :: ModuleName -> EntityReference
+ Hydra: EntityReferencePackage :: PackageName -> EntityReference
+ Hydra: EntityReferenceTermExpr :: String -> EntityReference
+ Hydra: EntityReferenceTypeExpr :: String -> EntityReference
+ Hydra: ErrorChecking :: CheckingError -> Error
+ Hydra: ErrorDecoding :: DecodingError -> Error
+ Hydra: ErrorDuplicateBinding :: DuplicateBindingError -> Error
+ Hydra: ErrorDuplicateField :: DuplicateFieldError -> Error
+ Hydra: ErrorExtraction :: ExtractionError -> Error
+ Hydra: ErrorInference :: InferenceError -> Error
+ Hydra: ErrorInvalidLiteral :: InvalidLiteralError -> Error
+ Hydra: ErrorOther :: OtherError -> Error
+ Hydra: ErrorResolution :: ResolutionError -> Error
+ Hydra: ErrorUndefinedField :: UndefinedFieldError -> Error
+ Hydra: ErrorUndefinedTermVariable :: UndefinedTermVariableError -> Error
+ Hydra: ErrorUnexpectedTermVariant :: UnexpectedTermVariantError -> Error
+ Hydra: ErrorUnexpectedTypeVariant :: UnexpectedTypeVariantError -> Error
+ Hydra: ErrorUnification :: UnificationError -> Error
+ Hydra: ErrorUntypedTermVariable :: UntypedTermVariableError -> Error
+ Hydra: ExtraRecordFieldsError :: SubtermPath -> Name -> [Name] -> ExtraRecordFieldsError
+ Hydra: ExtractionErrorEmptyList :: EmptyListError -> ExtractionError
+ Hydra: ExtractionErrorMultipleBindings :: MultipleBindingsError -> ExtractionError
+ Hydra: ExtractionErrorMultipleFields :: MultipleFieldsError -> ExtractionError
+ Hydra: ExtractionErrorNoMatchingField :: NoMatchingFieldError -> ExtractionError
+ Hydra: ExtractionErrorNoSuchBinding :: NoSuchBindingError -> ExtractionError
+ Hydra: ExtractionErrorNotEnoughCases :: NotEnoughCasesError -> ExtractionError
+ Hydra: ExtractionErrorUnexpectedShape :: UnexpectedShapeError -> ExtractionError
+ Hydra: Field :: Name -> Term -> Field
+ Hydra: FieldType :: Name -> Type -> FieldType
+ Hydra: FloatTypeFloat32 :: FloatType
+ Hydra: FloatTypeFloat64 :: FloatType
+ Hydra: FloatValueFloat32 :: Float -> FloatValue
+ Hydra: FloatValueFloat64 :: Double -> FloatValue
+ Hydra: ForallType :: Name -> Type -> ForallType
+ Hydra: ForeignKey :: RelationName -> Map ColumnName ColumnName -> ForeignKey
+ Hydra: FunctionStructure :: [Name] -> [Name] -> [Binding] -> Term -> [Type] -> Maybe Type -> env -> FunctionStructure env
+ Hydra: FunctionType :: Type -> Type -> FunctionType
+ Hydra: Graph :: Map Name Term -> Map Name TypeScheme -> Map Name TypeVariableConstraints -> Set Name -> Map Name Term -> Map Name Primitive -> Map Name TypeScheme -> Set Name -> Graph
+ Hydra: GraphPattern :: Name -> [Pattern] -> GraphPattern
+ Hydra: HeaderRow :: [String] -> HeaderRow
+ Hydra: IncorrectUnificationError :: TypeSubst -> IncorrectUnificationError
+ Hydra: InferenceContext :: Int -> [SubtermStep] -> InferenceContext
+ Hydra: InferenceErrorChecking :: CheckingError -> InferenceError
+ Hydra: InferenceErrorOther :: OtherInferenceError -> InferenceError
+ Hydra: InferenceErrorUnification :: UnificationInferenceError -> InferenceError
+ Hydra: InferenceResult :: Term -> Type -> TypeSubst -> Map Name TypeVariableConstraints -> InferenceContext -> InferenceResult
+ Hydra: Injection :: Name -> Field -> Injection
+ Hydra: IntegerTypeBigint :: IntegerType
+ Hydra: IntegerTypeInt16 :: IntegerType
+ Hydra: IntegerTypeInt32 :: IntegerType
+ Hydra: IntegerTypeInt64 :: IntegerType
+ Hydra: IntegerTypeInt8 :: IntegerType
+ Hydra: IntegerTypeUint16 :: IntegerType
+ Hydra: IntegerTypeUint32 :: IntegerType
+ Hydra: IntegerTypeUint64 :: IntegerType
+ Hydra: IntegerTypeUint8 :: IntegerType
+ Hydra: IntegerValueBigint :: Integer -> IntegerValue
+ Hydra: IntegerValueInt16 :: Int16 -> IntegerValue
+ Hydra: IntegerValueInt32 :: Int -> IntegerValue
+ Hydra: IntegerValueInt64 :: Int64 -> IntegerValue
+ Hydra: IntegerValueInt8 :: Int8 -> IntegerValue
+ Hydra: IntegerValueUint16 :: Int -> IntegerValue
+ Hydra: IntegerValueUint32 :: Int64 -> IntegerValue
+ Hydra: IntegerValueUint64 :: Integer -> IntegerValue
+ Hydra: IntegerValueUint8 :: Int16 -> IntegerValue
+ Hydra: InvalidForallParameterNameError :: SubtermPath -> Name -> InvalidForallParameterNameError
+ Hydra: InvalidLambdaParameterNameError :: SubtermPath -> Name -> InvalidLambdaParameterNameError
+ Hydra: InvalidLetBindingNameError :: SubtermPath -> Name -> InvalidLetBindingNameError
+ Hydra: InvalidLiteralErrorTypeMismatch :: LiteralTypeMismatchError -> InvalidLiteralError
+ Hydra: InvalidTermErrorConstantCondition :: ConstantConditionError -> InvalidTermError
+ Hydra: InvalidTermErrorDuplicateBinding :: DuplicateBindingError -> InvalidTermError
+ Hydra: InvalidTermErrorDuplicateField :: DuplicateFieldError -> InvalidTermError
+ Hydra: InvalidTermErrorEmptyCaseStatement :: EmptyCaseStatementError -> InvalidTermError
+ Hydra: InvalidTermErrorEmptyLetBindings :: EmptyLetBindingsError -> InvalidTermError
+ Hydra: InvalidTermErrorEmptyTermAnnotation :: EmptyTermAnnotationError -> InvalidTermError
+ Hydra: InvalidTermErrorEmptyTypeNameInTerm :: EmptyTypeNameInTermError -> InvalidTermError
+ Hydra: InvalidTermErrorExtraRecordFields :: ExtraRecordFieldsError -> InvalidTermError
+ Hydra: InvalidTermErrorInvalidLambdaParameterName :: InvalidLambdaParameterNameError -> InvalidTermError
+ Hydra: InvalidTermErrorInvalidLetBindingName :: InvalidLetBindingNameError -> InvalidTermError
+ Hydra: InvalidTermErrorInvalidTypeLambdaParameterName :: InvalidTypeLambdaParameterNameError -> InvalidTermError
+ Hydra: InvalidTermErrorMissingCaseBranches :: MissingCaseBranchesError -> InvalidTermError
+ Hydra: InvalidTermErrorMissingRecordFields :: MissingRecordFieldsError -> InvalidTermError
+ Hydra: InvalidTermErrorNestedTermAnnotation :: NestedTermAnnotationError -> InvalidTermError
+ Hydra: InvalidTermErrorNominalTypeKindMismatch :: NominalTypeKindMismatchError -> InvalidTermError
+ Hydra: InvalidTermErrorRedundantWrapUnwrap :: RedundantWrapUnwrapError -> InvalidTermError
+ Hydra: InvalidTermErrorSelfApplication :: SelfApplicationError -> InvalidTermError
+ Hydra: InvalidTermErrorTermVariableShadowing :: TermVariableShadowingError -> InvalidTermError
+ Hydra: InvalidTermErrorTypeVariableShadowingInTypeLambda :: TypeVariableShadowingInTypeLambdaError -> InvalidTermError
+ Hydra: InvalidTermErrorUndeclaredVariant :: UndeclaredVariantError -> InvalidTermError
+ Hydra: InvalidTermErrorUndefinedTermVariable :: UndefinedTermVariableError -> InvalidTermError
+ Hydra: InvalidTermErrorUndefinedTypeVariableInBindingType :: UndefinedTypeVariableInBindingTypeError -> InvalidTermError
+ Hydra: InvalidTermErrorUndefinedTypeVariableInLambdaDomain :: UndefinedTypeVariableInLambdaDomainError -> InvalidTermError
+ Hydra: InvalidTermErrorUndefinedTypeVariableInTypeApplication :: UndefinedTypeVariableInTypeApplicationError -> InvalidTermError
+ Hydra: InvalidTermErrorUnknownCaseAlternative :: UnknownCaseAlternativeError -> InvalidTermError
+ Hydra: InvalidTermErrorUnknownPrimitiveName :: UnknownPrimitiveNameError -> InvalidTermError
+ Hydra: InvalidTermErrorUnknownProjectedField :: UnknownProjectedFieldError -> InvalidTermError
+ Hydra: InvalidTermErrorUnnecessaryIdentityApplication :: UnnecessaryIdentityApplicationError -> InvalidTermError
+ Hydra: InvalidTermErrorUnresolvedNominalType :: UnresolvedNominalTypeError -> InvalidTermError
+ Hydra: InvalidTermErrorUntypedTermVariable :: UntypedTermVariableError -> InvalidTermError
+ Hydra: InvalidTypeErrorDuplicateRecordTypeFieldNames :: DuplicateRecordTypeFieldNamesError -> InvalidTypeError
+ Hydra: InvalidTypeErrorDuplicateUnionTypeFieldNames :: DuplicateUnionTypeFieldNamesError -> InvalidTypeError
+ Hydra: InvalidTypeErrorEmptyRecordType :: EmptyRecordTypeError -> InvalidTypeError
+ Hydra: InvalidTypeErrorEmptyTypeAnnotation :: EmptyTypeAnnotationError -> InvalidTypeError
+ Hydra: InvalidTypeErrorEmptyUnionType :: EmptyUnionTypeError -> InvalidTypeError
+ Hydra: InvalidTypeErrorInvalidForallParameterName :: InvalidForallParameterNameError -> InvalidTypeError
+ Hydra: InvalidTypeErrorInvalidTypeSchemeVariableName :: InvalidTypeSchemeVariableNameError -> InvalidTypeError
+ Hydra: InvalidTypeErrorNestedTypeAnnotation :: NestedTypeAnnotationError -> InvalidTypeError
+ Hydra: InvalidTypeErrorNonComparableMapKeyType :: NonComparableMapKeyTypeError -> InvalidTypeError
+ Hydra: InvalidTypeErrorNonComparableSetElementType :: NonComparableSetElementTypeError -> InvalidTypeError
+ Hydra: InvalidTypeErrorSingleVariantUnion :: SingleVariantUnionError -> InvalidTypeError
+ Hydra: InvalidTypeErrorTypeVariableShadowingInForall :: TypeVariableShadowingInForallError -> InvalidTypeError
+ Hydra: InvalidTypeErrorUndefinedTypeVariable :: UndefinedTypeVariableError -> InvalidTypeError
+ Hydra: InvalidTypeErrorVoidInNonBottomPosition :: VoidInNonBottomPositionError -> InvalidTypeError
+ Hydra: InvalidTypeLambdaParameterNameError :: SubtermPath -> Name -> InvalidTypeLambdaParameterNameError
+ Hydra: InvalidTypeSchemeVariableNameError :: SubtermPath -> Name -> InvalidTypeSchemeVariableNameError
+ Hydra: Lambda :: Name -> Maybe Type -> Term -> Lambda
+ Hydra: LambdaVariableReference :: Name -> TermNodeId -> Type -> LambdaVariableReference
+ Hydra: Language :: LanguageName -> LanguageConstraints -> Set LanguageFeature -> CaseConventions -> FileExtension -> Language
+ Hydra: LanguageConstraints :: Set LiteralVariant -> Set FloatType -> Set IntegerType -> Set TermVariant -> Set TypeVariant -> (Type -> Bool) -> LanguageConstraints
+ Hydra: LanguageFeatureNestedCaseStatements :: LanguageFeature
+ Hydra: LanguageFeatureNestedPolymorphicLetBindings :: LanguageFeature
+ Hydra: LanguageFeaturePartialApplication :: LanguageFeature
+ Hydra: LanguageName :: String -> LanguageName
+ Hydra: Let :: [Binding] -> Term -> Let
+ Hydra: LetVariableReference :: Name -> TermNodeId -> Type -> LetVariableReference
+ Hydra: Library :: ModuleName -> String -> [Primitive] -> Library
+ Hydra: LifecycleInfo :: Maybe Version -> Maybe Version -> LifecycleInfo
+ Hydra: LiteralBinary :: ByteString -> Literal
+ Hydra: LiteralBoolean :: Bool -> Literal
+ Hydra: LiteralDecimal :: Scientific -> Literal
+ Hydra: LiteralFloat :: FloatValue -> Literal
+ Hydra: LiteralInteger :: IntegerValue -> Literal
+ Hydra: LiteralString :: String -> Literal
+ Hydra: LiteralTypeBinary :: LiteralType
+ Hydra: LiteralTypeBoolean :: LiteralType
+ Hydra: LiteralTypeDecimal :: LiteralType
+ Hydra: LiteralTypeFloat :: FloatType -> LiteralType
+ Hydra: LiteralTypeInteger :: IntegerType -> LiteralType
+ Hydra: LiteralTypeMismatchError :: LiteralType -> LiteralType -> LiteralTypeMismatchError
+ Hydra: LiteralTypeString :: LiteralType
+ Hydra: LiteralVariantBinary :: LiteralVariant
+ Hydra: LiteralVariantBoolean :: LiteralVariant
+ Hydra: LiteralVariantDecimal :: LiteralVariant
+ Hydra: LiteralVariantFloat :: LiteralVariant
+ Hydra: LiteralVariantInteger :: LiteralVariant
+ Hydra: LiteralVariantString :: LiteralVariant
+ Hydra: MapType :: Type -> Type -> MapType
+ Hydra: MissingCaseBranchesError :: SubtermPath -> Name -> [Name] -> MissingCaseBranchesError
+ Hydra: MissingRecordFieldsError :: SubtermPath -> Name -> [Name] -> MissingRecordFieldsError
+ Hydra: Module :: ModuleName -> Maybe EntityMetadata -> [ModuleDependency] -> [Definition] -> Module
+ Hydra: ModuleDependency :: ModuleName -> Maybe PackageName -> ModuleDependency
+ Hydra: ModuleName :: String -> ModuleName
+ Hydra: ModuleNames :: (ModuleName, n) -> Map ModuleName n -> ModuleNames n
+ Hydra: MultipleBindingsError :: Name -> MultipleBindingsError
+ Hydra: MultipleFieldsError :: Name -> MultipleFieldsError
+ Hydra: Name :: String -> Name
+ Hydra: NestedTermAnnotationError :: SubtermPath -> NestedTermAnnotationError
+ Hydra: NestedTypeAnnotationError :: SubtermPath -> NestedTypeAnnotationError
+ Hydra: NoMatchingFieldError :: Name -> NoMatchingFieldError
+ Hydra: NoSuchBindingError :: Name -> NoSuchBindingError
+ Hydra: NoSuchPrimitiveError :: Name -> NoSuchPrimitiveError
+ Hydra: NodeTerm :: Term -> Node
+ Hydra: NodeVariable :: Variable -> Node
+ Hydra: NodeWildcard :: Node
+ Hydra: NominalTypeKindMismatchError :: SubtermPath -> Name -> TypeVariant -> TypeVariant -> NominalTypeKindMismatchError
+ Hydra: NominalTypeReference :: Name -> NominalTypeReference
+ Hydra: NonComparableMapKeyTypeError :: SubtermPath -> Type -> NonComparableMapKeyTypeError
+ Hydra: NonComparableSetElementTypeError :: SubtermPath -> Type -> NonComparableSetElementTypeError
+ Hydra: NotAForallTypeError :: Type -> [Type] -> NotAForallTypeError
+ Hydra: NotAFunctionTypeError :: Type -> NotAFunctionTypeError
+ Hydra: OtherCheckingError :: SubtermPath -> String -> OtherCheckingError
+ Hydra: OtherError :: String -> OtherError
+ Hydra: OtherInferenceError :: SubtermPath -> String -> OtherInferenceError
+ Hydra: OtherResolutionError :: String -> OtherResolutionError
+ Hydra: Package :: PackageName -> Maybe EntityMetadata -> [PackageDependency] -> [Module] -> Package
+ Hydra: PackageDependency :: PackageName -> VersionSpecifier -> Maybe DependencyScope -> PackageDependency
+ Hydra: PackageName :: String -> PackageName
+ Hydra: PairType :: Type -> Type -> PairType
+ Hydra: Parameter :: Name -> Maybe String -> Type -> Bool -> Parameter
+ Hydra: ParseError :: String -> [Int] -> ParseError
+ Hydra: ParseResultFailure :: ParseError -> ParseResult a
+ Hydra: ParseResultSuccess :: ParseSuccess a -> ParseResult a
+ Hydra: ParseSuccess :: a -> [Int] -> ParseSuccess a
+ Hydra: Parser :: ([Int] -> ParseResult a) -> Parser a
+ Hydra: PathEquation :: Path -> Path -> PathEquation
+ Hydra: PathInverse :: Path -> Path
+ Hydra: PathRegex :: RegexSequence -> Path
+ Hydra: PathStep :: Step -> Path
+ Hydra: PatternConjunction :: [Pattern] -> Pattern
+ Hydra: PatternDisjunction :: [Pattern] -> Pattern
+ Hydra: PatternGraph :: GraphPattern -> Pattern
+ Hydra: PatternImplication :: Pattern -> Pattern -> PatternImplication
+ Hydra: PatternNegation :: Pattern -> Pattern
+ Hydra: PatternTriple :: TriplePattern -> Pattern
+ Hydra: PrecisionArbitrary :: Precision
+ Hydra: PrecisionBits :: Int -> Precision
+ Hydra: PrimaryKey :: [ColumnName] -> PrimaryKey
+ Hydra: Primitive :: PrimitiveDefinition -> (Graph -> [Term] -> Either Error Term) -> Primitive
+ Hydra: PrimitiveDefinition :: Name -> Maybe EntityMetadata -> TermSignature -> Bool -> Bool -> Maybe Term -> PrimitiveDefinition
+ Hydra: PrimitiveReference :: Name -> Type -> PrimitiveReference
+ Hydra: Projection :: Name -> Name -> Projection
+ Hydra: Provision :: Name -> ProvisionKind -> String -> Provision
+ Hydra: ProvisionKindRecommendation :: ProvisionKind
+ Hydra: ProvisionKindRequirement :: ProvisionKind
+ Hydra: QualifiedName :: Maybe ModuleName -> String -> QualifiedName
+ Hydra: Query :: [Variable] -> [Pattern] -> Query
+ Hydra: Range :: Int -> Int -> Range
+ Hydra: Record :: Name -> [Field] -> Record
+ Hydra: RedundantWrapUnwrapError :: SubtermPath -> Name -> RedundantWrapUnwrapError
+ Hydra: RegexQuantifierAtLeast :: Int -> RegexQuantifier
+ Hydra: RegexQuantifierExactly :: Int -> RegexQuantifier
+ Hydra: RegexQuantifierOne :: RegexQuantifier
+ Hydra: RegexQuantifierOneOrMore :: RegexQuantifier
+ Hydra: RegexQuantifierRange :: Range -> RegexQuantifier
+ Hydra: RegexQuantifierZeroOrMore :: RegexQuantifier
+ Hydra: RegexQuantifierZeroOrOne :: RegexQuantifier
+ Hydra: RegexSequence :: Path -> RegexQuantifier -> RegexSequence
+ Hydra: Relation :: [Row v] -> Relation v
+ Hydra: RelationName :: String -> RelationName
+ Hydra: RelationSchema :: RelationName -> [ColumnSchema t] -> [PrimaryKey] -> [ForeignKey] -> RelationSchema t
+ Hydra: Relationship :: Set (Map ColumnName v) -> Relationship v
+ Hydra: ResolutionErrorNoMatchingField :: NoMatchingFieldError -> ResolutionError
+ Hydra: ResolutionErrorNoSuchBinding :: NoSuchBindingError -> ResolutionError
+ Hydra: ResolutionErrorNoSuchPrimitive :: NoSuchPrimitiveError -> ResolutionError
+ Hydra: ResolutionErrorOther :: OtherResolutionError -> ResolutionError
+ Hydra: ResolutionErrorUnexpectedShape :: UnexpectedShapeError -> ResolutionError
+ Hydra: Result :: Maybe String -> Type -> Result
+ Hydra: Row :: [v] -> Row v
+ Hydra: SelfApplicationError :: SubtermPath -> Name -> SelfApplicationError
+ Hydra: SingleVariantUnionError :: SubtermPath -> Name -> SingleVariantUnionError
+ Hydra: StepCompare :: ComparisonConstraint -> Step
+ Hydra: StepEdge :: Edge -> Step
+ Hydra: StepProject :: Projection -> Step
+ Hydra: SubtermLink :: SubtermStep -> TermNode -> SubtermLink
+ Hydra: SubtermPath :: [SubtermStep] -> SubtermPath
+ Hydra: SubtermStepAnnotatedAnnotation :: SubtermStep
+ Hydra: SubtermStepAnnotatedBody :: SubtermStep
+ Hydra: SubtermStepApplicationArgument :: SubtermStep
+ Hydra: SubtermStepApplicationFunction :: SubtermStep
+ Hydra: SubtermStepCasesCase :: Name -> SubtermStep
+ Hydra: SubtermStepCasesDefault :: SubtermStep
+ Hydra: SubtermStepEitherLeft :: SubtermStep
+ Hydra: SubtermStepEitherRight :: SubtermStep
+ Hydra: SubtermStepInjectField :: Name -> SubtermStep
+ Hydra: SubtermStepLambdaBody :: SubtermStep
+ Hydra: SubtermStepLetBinding :: Name -> SubtermStep
+ Hydra: SubtermStepLetBody :: SubtermStep
+ Hydra: SubtermStepListElement :: Int -> SubtermStep
+ Hydra: SubtermStepMapEntry :: Int -> SubtermStep
+ Hydra: SubtermStepOptionalGiven :: SubtermStep
+ Hydra: SubtermStepPairFirst :: SubtermStep
+ Hydra: SubtermStepPairSecond :: SubtermStep
+ Hydra: SubtermStepRecordField :: Name -> SubtermStep
+ Hydra: SubtermStepSetElement :: Int -> SubtermStep
+ Hydra: SubtermStepTypeApplicationBody :: SubtermStep
+ Hydra: SubtermStepTypeLambdaBody :: SubtermStep
+ Hydra: SubtermStepWrapBody :: SubtermStep
+ Hydra: SubtypeLink :: SubtypeStep -> TypeNode -> SubtypeLink
+ Hydra: SubtypePath :: [SubtypeStep] -> SubtypePath
+ Hydra: SubtypeStepAnnotatedBody :: SubtypeStep
+ Hydra: SubtypeStepApplicationArgument :: SubtypeStep
+ Hydra: SubtypeStepApplicationFunction :: SubtypeStep
+ Hydra: SubtypeStepEffectValue :: SubtypeStep
+ Hydra: SubtypeStepEitherLeft :: SubtypeStep
+ Hydra: SubtypeStepEitherRight :: SubtypeStep
+ Hydra: SubtypeStepForallBody :: SubtypeStep
+ Hydra: SubtypeStepFunctionCodomain :: SubtypeStep
+ Hydra: SubtypeStepFunctionDomain :: SubtypeStep
+ Hydra: SubtypeStepListElement :: SubtypeStep
+ Hydra: SubtypeStepMapKeys :: SubtypeStep
+ Hydra: SubtypeStepMapValues :: SubtypeStep
+ Hydra: SubtypeStepOptionalElement :: SubtypeStep
+ Hydra: SubtypeStepPairFirst :: SubtypeStep
+ Hydra: SubtypeStepPairSecond :: SubtypeStep
+ Hydra: SubtypeStepRecordField :: Name -> SubtypeStep
+ Hydra: SubtypeStepSetElement :: SubtypeStep
+ Hydra: SubtypeStepUnionField :: Name -> SubtypeStep
+ Hydra: SubtypeStepWrapBody :: SubtypeStep
+ Hydra: Table :: Maybe HeaderRow -> [DataRow v] -> Table v
+ Hydra: TableType :: RelationName -> [ColumnType] -> TableType
+ Hydra: Tag :: String -> Tag
+ Hydra: TermAnnotated :: AnnotatedTerm -> Term
+ Hydra: TermApplication :: Application -> Term
+ Hydra: TermAttributeLinkCasesTypeName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkInjectTypeName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkLambdaDomainGiven :: Type -> TermAttributeLink
+ Hydra: TermAttributeLinkLambdaParameter :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkLetBindingTypeSchemeGiven :: (Name, TypeScheme) -> TermAttributeLink
+ Hydra: TermAttributeLinkLiteral :: Literal -> TermAttributeLink
+ Hydra: TermAttributeLinkProjectFieldName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkProjectTypeName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkRecordTypeName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkTypeApplicationType :: Type -> TermAttributeLink
+ Hydra: TermAttributeLinkTypeLambdaParameter :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkUnwrapTypeName :: Name -> TermAttributeLink
+ Hydra: TermAttributeLinkWrapTypeName :: Name -> TermAttributeLink
+ Hydra: TermCases :: CaseStatement -> Term
+ Hydra: TermCoder :: Type -> (InferenceContext -> Graph -> Term -> Either Error a) -> (InferenceContext -> a -> Either Error Term) -> TermCoder a
+ Hydra: TermDefinition :: Name -> Maybe EntityMetadata -> Maybe TermSignature -> Term -> TermDefinition
+ Hydra: TermEither :: Either Term Term -> Term
+ Hydra: TermGraph :: Map Name TermNode -> TermGraph
+ Hydra: TermInject :: Injection -> Term
+ Hydra: TermLambda :: Lambda -> Term
+ Hydra: TermLet :: Let -> Term
+ Hydra: TermLinkAttribute :: TermAttributeLink -> TermLink
+ Hydra: TermLinkReference :: TermReferenceLink -> TermLink
+ Hydra: TermLinkSubterm :: SubtermLink -> TermLink
+ Hydra: TermList :: [Term] -> Term
+ Hydra: TermLiteral :: Literal -> Term
+ Hydra: TermMap :: Map Term Term -> Term
+ Hydra: TermNode :: Term -> Type -> [TermLink] -> TermNode
+ Hydra: TermNodeId :: Name -> SubtermPath -> TermNodeId
+ Hydra: TermOptional :: Maybe Term -> Term
+ Hydra: TermPair :: (Term, Term) -> Term
+ Hydra: TermProject :: Projection -> Term
+ Hydra: TermRecord :: Record -> Term
+ Hydra: TermReferenceLambda :: LambdaVariableReference -> TermReference
+ Hydra: TermReferenceLet :: LetVariableReference -> TermReference
+ Hydra: TermReferenceLink :: SubtermStep -> TermReference -> TermReferenceLink
+ Hydra: TermReferencePrimitive :: PrimitiveReference -> TermReference
+ Hydra: TermSet :: Set Term -> Term
+ Hydra: TermSignature :: [TypeParameter] -> [Parameter] -> Result -> TermSignature
+ Hydra: TermSubst :: Map Name Term -> TermSubst
+ Hydra: TermTypeApplication :: TypeApplicationTerm -> Term
+ Hydra: TermTypeLambda :: TypeLambda -> Term
+ Hydra: TermUnit :: Term
+ Hydra: TermUnwrap :: Name -> Term
+ Hydra: TermVariable :: Name -> Term
+ Hydra: TermVariableShadowingError :: SubtermPath -> Name -> TermVariableShadowingError
+ Hydra: TermVariantAnnotated :: TermVariant
+ Hydra: TermVariantApplication :: TermVariant
+ Hydra: TermVariantCases :: TermVariant
+ Hydra: TermVariantEither :: TermVariant
+ Hydra: TermVariantInject :: TermVariant
+ Hydra: TermVariantLambda :: TermVariant
+ Hydra: TermVariantLet :: TermVariant
+ Hydra: TermVariantList :: TermVariant
+ Hydra: TermVariantLiteral :: TermVariant
+ Hydra: TermVariantMap :: TermVariant
+ Hydra: TermVariantOptional :: TermVariant
+ Hydra: TermVariantPair :: TermVariant
+ Hydra: TermVariantProject :: TermVariant
+ Hydra: TermVariantRecord :: TermVariant
+ Hydra: TermVariantSet :: TermVariant
+ Hydra: TermVariantTypeApplication :: TermVariant
+ Hydra: TermVariantTypeLambda :: TermVariant
+ Hydra: TermVariantUnit :: TermVariant
+ Hydra: TermVariantUnwrap :: TermVariant
+ Hydra: TermVariantVariable :: TermVariant
+ Hydra: TermVariantWrap :: TermVariant
+ Hydra: TermWrap :: WrappedTerm -> Term
+ Hydra: TestCaseEffectful :: EffectfulTestCase -> TestCase
+ Hydra: TestCaseUniversal :: UniversalTestCase -> TestCase
+ Hydra: TestCaseWithMetadata :: String -> TestCase -> Maybe String -> [Tag] -> [Name] -> TestCaseWithMetadata
+ Hydra: TestGroup :: String -> Maybe String -> [TestGroup] -> [TestCaseWithMetadata] -> TestGroup
+ Hydra: TraversalOrderPost :: TraversalOrder
+ Hydra: TraversalOrderPre :: TraversalOrder
+ Hydra: TriplePattern :: Node -> Path -> Node -> TriplePattern
+ Hydra: TypeAnnotated :: AnnotatedType -> Type
+ Hydra: TypeApplication :: ApplicationType -> Type
+ Hydra: TypeApplicationTerm :: Term -> Type -> TypeApplicationTerm
+ Hydra: TypeArityMismatchError :: Type -> Int -> Int -> [Type] -> TypeArityMismatchError
+ Hydra: TypeAttributeLinkAnnotatedAnnotation :: Term -> TypeAttributeLink
+ Hydra: TypeAttributeLinkForallParameter :: Name -> TypeAttributeLink
+ Hydra: TypeAttributeLinkLiteral :: LiteralType -> TypeAttributeLink
+ Hydra: TypeClass :: String -> TypeClass
+ Hydra: TypeClassConstraintSimple :: Name -> TypeClassConstraint
+ Hydra: TypeConstraint :: Type -> Type -> String -> TypeConstraint
+ Hydra: TypeDefinition :: Name -> Maybe EntityMetadata -> TypeScheme -> TypeDefinition
+ Hydra: TypeEffect :: Type -> Type
+ Hydra: TypeEither :: EitherType -> Type
+ Hydra: TypeForall :: ForallType -> Type
+ Hydra: TypeFunction :: FunctionType -> Type
+ Hydra: TypeGraph :: Map Name TypeNode -> TypeGraph
+ Hydra: TypeLambda :: Name -> Term -> TypeLambda
+ Hydra: TypeLinkAttribute :: TypeAttributeLink -> TypeLink
+ Hydra: TypeLinkReference :: TypeReferenceLink -> TypeLink
+ Hydra: TypeLinkSubtype :: SubtypeLink -> TypeLink
+ Hydra: TypeList :: Type -> Type
+ Hydra: TypeLiteral :: LiteralType -> Type
+ Hydra: TypeMap :: MapType -> Type
+ Hydra: TypeMismatchError :: Type -> Type -> TypeMismatchError
+ Hydra: TypeNode :: Type -> [TypeLink] -> TypeNode
+ Hydra: TypeNodeId :: Name -> SubtypePath -> TypeNodeId
+ Hydra: TypeOptional :: Type -> Type
+ Hydra: TypePair :: PairType -> Type
+ Hydra: TypeParameter :: Name -> [TypeClassConstraint] -> TypeParameter
+ Hydra: TypeRecord :: [FieldType] -> Type
+ Hydra: TypeReferenceLink :: SubtypeStep -> TypeReference -> TypeReferenceLink
+ Hydra: TypeReferenceNominal :: NominalTypeReference -> TypeReference
+ Hydra: TypeReferenceVariable :: TypeVariableReference -> TypeReference
+ Hydra: TypeScheme :: [Name] -> Type -> Map Name TypeVariableConstraints -> TypeScheme
+ Hydra: TypeSet :: Type -> Type
+ Hydra: TypeSubst :: Map Name Type -> TypeSubst
+ Hydra: TypeUnion :: [FieldType] -> Type
+ Hydra: TypeUnit :: Type
+ Hydra: TypeVariable :: Name -> Type
+ Hydra: TypeVariableConstraints :: Set TypeClassConstraint -> TypeVariableConstraints
+ Hydra: TypeVariableReference :: Name -> TypeNodeId -> TypeVariableReference
+ Hydra: TypeVariableShadowingInForallError :: SubtermPath -> Name -> TypeVariableShadowingInForallError
+ Hydra: TypeVariableShadowingInTypeLambdaError :: SubtermPath -> Name -> TypeVariableShadowingInTypeLambdaError
+ Hydra: TypeVariantAnnotated :: TypeVariant
+ Hydra: TypeVariantApplication :: TypeVariant
+ Hydra: TypeVariantEffect :: TypeVariant
+ Hydra: TypeVariantEither :: TypeVariant
+ Hydra: TypeVariantForall :: TypeVariant
+ Hydra: TypeVariantFunction :: TypeVariant
+ Hydra: TypeVariantList :: TypeVariant
+ Hydra: TypeVariantLiteral :: TypeVariant
+ Hydra: TypeVariantMap :: TypeVariant
+ Hydra: TypeVariantOptional :: TypeVariant
+ Hydra: TypeVariantPair :: TypeVariant
+ Hydra: TypeVariantRecord :: TypeVariant
+ Hydra: TypeVariantSet :: TypeVariant
+ Hydra: TypeVariantUnion :: TypeVariant
+ Hydra: TypeVariantUnit :: TypeVariant
+ Hydra: TypeVariantVariable :: TypeVariant
+ Hydra: TypeVariantVoid :: TypeVariant
+ Hydra: TypeVariantWrap :: TypeVariant
+ Hydra: TypeVoid :: Type
+ Hydra: TypeWrap :: Type -> Type
+ Hydra: TypedBinding :: Name -> TypedTerm a -> TypedBinding a
+ Hydra: TypedName :: Name -> TypedName a
+ Hydra: TypedTerm :: Term -> TypedTerm a
+ Hydra: TypedTermDefinition :: Name -> TypedTerm a -> TypedTermDefinition a
+ Hydra: UnboundTypeVariablesError :: Set Name -> Type -> UnboundTypeVariablesError
+ Hydra: UndeclaredVariantError :: SubtermPath -> Name -> Name -> UndeclaredVariantError
+ Hydra: UndefinedFieldError :: Name -> Name -> UndefinedFieldError
+ Hydra: UndefinedTermVariableCheckingError :: SubtermPath -> Name -> UndefinedTermVariableCheckingError
+ Hydra: UndefinedTermVariableError :: SubtermPath -> Name -> UndefinedTermVariableError
+ Hydra: UndefinedTypeVariableError :: SubtermPath -> Name -> UndefinedTypeVariableError
+ Hydra: UndefinedTypeVariableInBindingTypeError :: SubtermPath -> Name -> UndefinedTypeVariableInBindingTypeError
+ Hydra: UndefinedTypeVariableInLambdaDomainError :: SubtermPath -> Name -> UndefinedTypeVariableInLambdaDomainError
+ Hydra: UndefinedTypeVariableInTypeApplicationError :: SubtermPath -> Name -> UndefinedTypeVariableInTypeApplicationError
+ Hydra: UnequalTypesError :: [Type] -> String -> UnequalTypesError
+ Hydra: UnexpectedShapeError :: String -> String -> UnexpectedShapeError
+ Hydra: UnexpectedTermVariantError :: TermVariant -> Term -> UnexpectedTermVariantError
+ Hydra: UnexpectedTypeVariantError :: TypeVariant -> Type -> UnexpectedTypeVariantError
+ Hydra: UnificationError :: Type -> Type -> String -> UnificationError
+ Hydra: UnificationInferenceError :: SubtermPath -> UnificationError -> UnificationInferenceError
+ Hydra: UniversalTestCase :: (() -> String) -> (() -> String) -> UniversalTestCase
+ Hydra: UnknownCaseAlternativeError :: SubtermPath -> Name -> Name -> UnknownCaseAlternativeError
+ Hydra: UnknownPrimitiveNameError :: SubtermPath -> Name -> UnknownPrimitiveNameError
+ Hydra: UnknownProjectedFieldError :: SubtermPath -> Name -> Name -> UnknownProjectedFieldError
+ Hydra: UnnecessaryIdentityApplicationError :: SubtermPath -> UnnecessaryIdentityApplicationError
+ Hydra: UnresolvedNominalTypeError :: SubtermPath -> Name -> UnresolvedNominalTypeError
+ Hydra: UnsupportedTermVariantError :: TermVariant -> UnsupportedTermVariantError
+ Hydra: UntypedLambdaError :: UntypedLambdaError
+ Hydra: UntypedLetBindingError :: Binding -> UntypedLetBindingError
+ Hydra: UntypedTermVariableCheckingError :: SubtermPath -> Name -> UntypedTermVariableCheckingError
+ Hydra: UntypedTermVariableError :: SubtermPath -> Name -> UntypedTermVariableError
+ Hydra: ValidationProfile :: Set Name -> Set Name -> Int -> Int -> ValidationProfile
+ Hydra: ValidationResult :: [e] -> [e] -> ValidationResult e
+ Hydra: Variable :: String -> Variable
+ Hydra: Version :: String -> Version
+ Hydra: VersionRange :: Maybe Version -> Maybe Version -> VersionRange
+ Hydra: VersionSpecifierAny :: VersionSpecifier
+ Hydra: VersionSpecifierAtLeast :: Version -> VersionSpecifier
+ Hydra: VersionSpecifierExact :: Version -> VersionSpecifier
+ Hydra: VersionSpecifierRange :: VersionRange -> VersionSpecifier
+ Hydra: VoidInNonBottomPositionError :: SubtermPath -> VoidInNonBottomPositionError
+ Hydra: WrappedTerm :: Name -> Term -> WrappedTerm
+ Hydra: [adapterCoder] :: Adapter t1 t2 v1 v2 e -> Coder v1 v2 e
+ Hydra: [adapterContextAdapters] :: AdapterContext -> Map Name (Adapter Type Type Term Term Error)
+ Hydra: [adapterContextGraph] :: AdapterContext -> Graph
+ Hydra: [adapterContextLanguage] :: AdapterContext -> Language
+ Hydra: [adapterIsLossy] :: Adapter t1 t2 v1 v2 e -> Bool
+ Hydra: [adapterSource] :: Adapter t1 t2 v1 v2 e -> t1
+ Hydra: [adapterTarget] :: Adapter t1 t2 v1 v2 e -> t2
+ Hydra: [annotatedTermAnnotation] :: AnnotatedTerm -> Term
+ Hydra: [annotatedTermBody] :: AnnotatedTerm -> Term
+ Hydra: [annotatedTypeAnnotation] :: AnnotatedType -> Term
+ Hydra: [annotatedTypeBody] :: AnnotatedType -> Type
+ Hydra: [applicationArgument] :: Application -> Term
+ Hydra: [applicationFunction] :: Application -> Term
+ Hydra: [applicationTypeArgument] :: ApplicationType -> Type
+ Hydra: [applicationTypeFunction] :: ApplicationType -> Type
+ Hydra: [bicoderDecode] :: Bicoder t1 t2 v1 v2 e -> t2 -> Adapter t2 t1 v2 v1 e
+ Hydra: [bicoderEncode] :: Bicoder t1 t2 v1 v2 e -> t1 -> Adapter t1 t2 v1 v2 e
+ Hydra: [bindingName] :: Binding -> Name
+ Hydra: [bindingTerm] :: Binding -> Term
+ Hydra: [bindingTypeScheme] :: Binding -> Maybe TypeScheme
+ Hydra: [caseAlternativeHandler] :: CaseAlternative -> Term
+ Hydra: [caseAlternativeName] :: CaseAlternative -> Name
+ Hydra: [caseConventionsConstant] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsDirectory] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsEnumValue] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsField] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsFile] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsModule] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsTermVariable] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsTerm] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsTypeVariable] :: CaseConventions -> CaseConvention
+ Hydra: [caseConventionsType] :: CaseConventions -> CaseConvention
+ Hydra: [caseStatementCases] :: CaseStatement -> [CaseAlternative]
+ Hydra: [caseStatementDefault] :: CaseStatement -> Maybe Term
+ Hydra: [caseStatementTypeName] :: CaseStatement -> Name
+ Hydra: [coderDecode] :: Coder v1 v2 e -> v2 -> Either e v1
+ Hydra: [coderEncode] :: Coder v1 v2 e -> v1 -> Either e v2
+ Hydra: [columnSchemaDomain] :: ColumnSchema t -> t
+ Hydra: [columnSchemaName] :: ColumnSchema t -> ColumnName
+ Hydra: [columnTypeName] :: ColumnType -> ColumnName
+ Hydra: [columnTypeType] :: ColumnType -> Type
+ Hydra: [constantConditionErrorLocation] :: ConstantConditionError -> SubtermPath
+ Hydra: [constantConditionErrorValue] :: ConstantConditionError -> Bool
+ Hydra: [duplicateBindingErrorLocation] :: DuplicateBindingError -> SubtermPath
+ Hydra: [duplicateBindingErrorName] :: DuplicateBindingError -> Name
+ Hydra: [duplicateFieldErrorLocation] :: DuplicateFieldError -> SubtermPath
+ Hydra: [duplicateFieldErrorName] :: DuplicateFieldError -> Name
+ Hydra: [duplicateRecordTypeFieldNamesErrorLocation] :: DuplicateRecordTypeFieldNamesError -> SubtermPath
+ Hydra: [duplicateRecordTypeFieldNamesErrorName] :: DuplicateRecordTypeFieldNamesError -> Name
+ Hydra: [duplicateUnionTypeFieldNamesErrorLocation] :: DuplicateUnionTypeFieldNamesError -> SubtermPath
+ Hydra: [duplicateUnionTypeFieldNamesErrorName] :: DuplicateUnionTypeFieldNamesError -> Name
+ Hydra: [edgeIn] :: Edge -> Maybe Name
+ Hydra: [edgeOut] :: Edge -> Maybe Name
+ Hydra: [edgeType] :: Edge -> Name
+ Hydra: [effectfulTestCaseActual] :: EffectfulTestCase -> () -> IO String
+ Hydra: [effectfulTestCaseExpected] :: EffectfulTestCase -> () -> String
+ Hydra: [eitherTypeLeft] :: EitherType -> Type
+ Hydra: [eitherTypeRight] :: EitherType -> Type
+ Hydra: [emptyCaseStatementErrorLocation] :: EmptyCaseStatementError -> SubtermPath
+ Hydra: [emptyCaseStatementErrorTypeName] :: EmptyCaseStatementError -> Name
+ Hydra: [emptyLetBindingsErrorLocation] :: EmptyLetBindingsError -> SubtermPath
+ Hydra: [emptyRecordTypeErrorLocation] :: EmptyRecordTypeError -> SubtermPath
+ Hydra: [emptyTermAnnotationErrorLocation] :: EmptyTermAnnotationError -> SubtermPath
+ Hydra: [emptyTypeAnnotationErrorLocation] :: EmptyTypeAnnotationError -> SubtermPath
+ Hydra: [emptyTypeNameInTermErrorLocation] :: EmptyTypeNameInTermError -> SubtermPath
+ Hydra: [emptyUnionTypeErrorLocation] :: EmptyUnionTypeError -> SubtermPath
+ Hydra: [entityMetadataComments] :: EntityMetadata -> [String]
+ Hydra: [entityMetadataDescription] :: EntityMetadata -> Maybe String
+ Hydra: [entityMetadataLifecycle] :: EntityMetadata -> Maybe LifecycleInfo
+ Hydra: [entityMetadataProvisions] :: EntityMetadata -> [Provision]
+ Hydra: [entityMetadataSeeAlso] :: EntityMetadata -> [EntityReference]
+ Hydra: [extraRecordFieldsErrorFieldNames] :: ExtraRecordFieldsError -> [Name]
+ Hydra: [extraRecordFieldsErrorLocation] :: ExtraRecordFieldsError -> SubtermPath
+ Hydra: [extraRecordFieldsErrorTypeName] :: ExtraRecordFieldsError -> Name
+ Hydra: [fieldName] :: Field -> Name
+ Hydra: [fieldTerm] :: Field -> Term
+ Hydra: [fieldTypeName] :: FieldType -> Name
+ Hydra: [fieldTypeType] :: FieldType -> Type
+ Hydra: [forallTypeBody] :: ForallType -> Type
+ Hydra: [forallTypeParameter] :: ForallType -> Name
+ Hydra: [foreignKeyForeignRelation] :: ForeignKey -> RelationName
+ Hydra: [foreignKeyKeys] :: ForeignKey -> Map ColumnName ColumnName
+ Hydra: [functionStructureBindings] :: FunctionStructure env -> [Binding]
+ Hydra: [functionStructureBody] :: FunctionStructure env -> Term
+ Hydra: [functionStructureCodomain] :: FunctionStructure env -> Maybe Type
+ Hydra: [functionStructureDomains] :: FunctionStructure env -> [Type]
+ Hydra: [functionStructureEnvironment] :: FunctionStructure env -> env
+ Hydra: [functionStructureParams] :: FunctionStructure env -> [Name]
+ Hydra: [functionStructureTypeParams] :: FunctionStructure env -> [Name]
+ Hydra: [functionTypeCodomain] :: FunctionType -> Type
+ Hydra: [functionTypeDomain] :: FunctionType -> Type
+ Hydra: [graphBoundTerms] :: Graph -> Map Name Term
+ Hydra: [graphBoundTypes] :: Graph -> Map Name TypeScheme
+ Hydra: [graphClassConstraints] :: Graph -> Map Name TypeVariableConstraints
+ Hydra: [graphLambdaVariables] :: Graph -> Set Name
+ Hydra: [graphMetadata] :: Graph -> Map Name Term
+ Hydra: [graphPatternGraph] :: GraphPattern -> Name
+ Hydra: [graphPatternPatterns] :: GraphPattern -> [Pattern]
+ Hydra: [graphPrimitives] :: Graph -> Map Name Primitive
+ Hydra: [graphSchemaTypes] :: Graph -> Map Name TypeScheme
+ Hydra: [graphTypeVariables] :: Graph -> Set Name
+ Hydra: [incorrectUnificationErrorSubstitution] :: IncorrectUnificationError -> TypeSubst
+ Hydra: [inferenceContextFreshTypeVariableCount] :: InferenceContext -> Int
+ Hydra: [inferenceContextTrace] :: InferenceContext -> [SubtermStep]
+ Hydra: [inferenceResultClassConstraints] :: InferenceResult -> Map Name TypeVariableConstraints
+ Hydra: [inferenceResultContext] :: InferenceResult -> InferenceContext
+ Hydra: [inferenceResultSubst] :: InferenceResult -> TypeSubst
+ Hydra: [inferenceResultTerm] :: InferenceResult -> Term
+ Hydra: [inferenceResultType] :: InferenceResult -> Type
+ Hydra: [injectionField] :: Injection -> Field
+ Hydra: [injectionTypeName] :: Injection -> Name
+ Hydra: [invalidForallParameterNameErrorLocation] :: InvalidForallParameterNameError -> SubtermPath
+ Hydra: [invalidForallParameterNameErrorName] :: InvalidForallParameterNameError -> Name
+ Hydra: [invalidLambdaParameterNameErrorLocation] :: InvalidLambdaParameterNameError -> SubtermPath
+ Hydra: [invalidLambdaParameterNameErrorName] :: InvalidLambdaParameterNameError -> Name
+ Hydra: [invalidLetBindingNameErrorLocation] :: InvalidLetBindingNameError -> SubtermPath
+ Hydra: [invalidLetBindingNameErrorName] :: InvalidLetBindingNameError -> Name
+ Hydra: [invalidTypeLambdaParameterNameErrorLocation] :: InvalidTypeLambdaParameterNameError -> SubtermPath
+ Hydra: [invalidTypeLambdaParameterNameErrorName] :: InvalidTypeLambdaParameterNameError -> Name
+ Hydra: [invalidTypeSchemeVariableNameErrorLocation] :: InvalidTypeSchemeVariableNameError -> SubtermPath
+ Hydra: [invalidTypeSchemeVariableNameErrorName] :: InvalidTypeSchemeVariableNameError -> Name
+ Hydra: [lambdaBody] :: Lambda -> Term
+ Hydra: [lambdaDomain] :: Lambda -> Maybe Type
+ Hydra: [lambdaParameter] :: Lambda -> Name
+ Hydra: [lambdaVariableReferenceBoundByNode] :: LambdaVariableReference -> TermNodeId
+ Hydra: [lambdaVariableReferenceType] :: LambdaVariableReference -> Type
+ Hydra: [lambdaVariableReferenceVariable] :: LambdaVariableReference -> Name
+ Hydra: [languageCaseConventions] :: Language -> CaseConventions
+ Hydra: [languageConstraintsFloatTypes] :: LanguageConstraints -> Set FloatType
+ Hydra: [languageConstraintsIntegerTypes] :: LanguageConstraints -> Set IntegerType
+ Hydra: [languageConstraintsLiteralVariants] :: LanguageConstraints -> Set LiteralVariant
+ Hydra: [languageConstraintsTermVariants] :: LanguageConstraints -> Set TermVariant
+ Hydra: [languageConstraintsTypeVariants] :: LanguageConstraints -> Set TypeVariant
+ Hydra: [languageConstraintsTypes] :: LanguageConstraints -> Type -> Bool
+ Hydra: [languageConstraints] :: Language -> LanguageConstraints
+ Hydra: [languageDefaultFileExtension] :: Language -> FileExtension
+ Hydra: [languageName] :: Language -> LanguageName
+ Hydra: [languageSupportedFeatures] :: Language -> Set LanguageFeature
+ Hydra: [letBindings] :: Let -> [Binding]
+ Hydra: [letBody] :: Let -> Term
+ Hydra: [letVariableReferenceBindingNode] :: LetVariableReference -> TermNodeId
+ Hydra: [letVariableReferenceType] :: LetVariableReference -> Type
+ Hydra: [letVariableReferenceVariable] :: LetVariableReference -> Name
+ Hydra: [libraryName] :: Library -> ModuleName
+ Hydra: [libraryPrefix] :: Library -> String
+ Hydra: [libraryPrimitives] :: Library -> [Primitive]
+ Hydra: [lifecycleInfoAvailableSince] :: LifecycleInfo -> Maybe Version
+ Hydra: [lifecycleInfoDeprecatedSince] :: LifecycleInfo -> Maybe Version
+ Hydra: [literalTypeMismatchErrorActualType] :: LiteralTypeMismatchError -> LiteralType
+ Hydra: [literalTypeMismatchErrorExpectedType] :: LiteralTypeMismatchError -> LiteralType
+ Hydra: [mapTypeKeys] :: MapType -> Type
+ Hydra: [mapTypeValues] :: MapType -> Type
+ Hydra: [missingCaseBranchesErrorLocation] :: MissingCaseBranchesError -> SubtermPath
+ Hydra: [missingCaseBranchesErrorTypeName] :: MissingCaseBranchesError -> Name
+ Hydra: [missingCaseBranchesErrorVariantNames] :: MissingCaseBranchesError -> [Name]
+ Hydra: [missingRecordFieldsErrorFieldNames] :: MissingRecordFieldsError -> [Name]
+ Hydra: [missingRecordFieldsErrorLocation] :: MissingRecordFieldsError -> SubtermPath
+ Hydra: [missingRecordFieldsErrorTypeName] :: MissingRecordFieldsError -> Name
+ Hydra: [moduleDefinitions] :: Module -> [Definition]
+ Hydra: [moduleDependencies] :: Module -> [ModuleDependency]
+ Hydra: [moduleDependencyModule] :: ModuleDependency -> ModuleName
+ Hydra: [moduleDependencyPackage] :: ModuleDependency -> Maybe PackageName
+ Hydra: [moduleMetadata] :: Module -> Maybe EntityMetadata
+ Hydra: [moduleName] :: Module -> ModuleName
+ Hydra: [moduleNamesFocus] :: ModuleNames n -> (ModuleName, n)
+ Hydra: [moduleNamesMapping] :: ModuleNames n -> Map ModuleName n
+ Hydra: [multipleBindingsErrorName] :: MultipleBindingsError -> Name
+ Hydra: [multipleFieldsErrorFieldName] :: MultipleFieldsError -> Name
+ Hydra: [nestedTermAnnotationErrorLocation] :: NestedTermAnnotationError -> SubtermPath
+ Hydra: [nestedTypeAnnotationErrorLocation] :: NestedTypeAnnotationError -> SubtermPath
+ Hydra: [noMatchingFieldErrorFieldName] :: NoMatchingFieldError -> Name
+ Hydra: [noSuchBindingErrorName] :: NoSuchBindingError -> Name
+ Hydra: [noSuchPrimitiveErrorName] :: NoSuchPrimitiveError -> Name
+ Hydra: [nominalTypeKindMismatchErrorActualVariant] :: NominalTypeKindMismatchError -> TypeVariant
+ Hydra: [nominalTypeKindMismatchErrorExpectedVariant] :: NominalTypeKindMismatchError -> TypeVariant
+ Hydra: [nominalTypeKindMismatchErrorLocation] :: NominalTypeKindMismatchError -> SubtermPath
+ Hydra: [nominalTypeKindMismatchErrorTypeName] :: NominalTypeKindMismatchError -> Name
+ Hydra: [nominalTypeReferenceName] :: NominalTypeReference -> Name
+ Hydra: [nonComparableMapKeyTypeErrorKeyType] :: NonComparableMapKeyTypeError -> Type
+ Hydra: [nonComparableMapKeyTypeErrorLocation] :: NonComparableMapKeyTypeError -> SubtermPath
+ Hydra: [nonComparableSetElementTypeErrorElementType] :: NonComparableSetElementTypeError -> Type
+ Hydra: [nonComparableSetElementTypeErrorLocation] :: NonComparableSetElementTypeError -> SubtermPath
+ Hydra: [notAForallTypeErrorTypeArguments] :: NotAForallTypeError -> [Type]
+ Hydra: [notAForallTypeErrorType] :: NotAForallTypeError -> Type
+ Hydra: [notAFunctionTypeErrorType] :: NotAFunctionTypeError -> Type
+ Hydra: [otherCheckingErrorMessage] :: OtherCheckingError -> String
+ Hydra: [otherCheckingErrorPath] :: OtherCheckingError -> SubtermPath
+ Hydra: [otherInferenceErrorMessage] :: OtherInferenceError -> String
+ Hydra: [otherInferenceErrorPath] :: OtherInferenceError -> SubtermPath
+ Hydra: [packageDependencies] :: Package -> [PackageDependency]
+ Hydra: [packageDependencyName] :: PackageDependency -> PackageName
+ Hydra: [packageDependencyScope] :: PackageDependency -> Maybe DependencyScope
+ Hydra: [packageDependencyVersion] :: PackageDependency -> VersionSpecifier
+ Hydra: [packageMetadata] :: Package -> Maybe EntityMetadata
+ Hydra: [packageModules] :: Package -> [Module]
+ Hydra: [packageName] :: Package -> PackageName
+ Hydra: [pairTypeFirst] :: PairType -> Type
+ Hydra: [pairTypeSecond] :: PairType -> Type
+ Hydra: [parameterDescription] :: Parameter -> Maybe String
+ Hydra: [parameterIsLazy] :: Parameter -> Bool
+ Hydra: [parameterName] :: Parameter -> Name
+ Hydra: [parameterType] :: Parameter -> Type
+ Hydra: [parseErrorMessage] :: ParseError -> String
+ Hydra: [parseErrorRemainder] :: ParseError -> [Int]
+ Hydra: [parseSuccessRemainder] :: ParseSuccess a -> [Int]
+ Hydra: [parseSuccessValue] :: ParseSuccess a -> a
+ Hydra: [pathEquationLeft] :: PathEquation -> Path
+ Hydra: [pathEquationRight] :: PathEquation -> Path
+ Hydra: [patternImplicationAntecedent] :: PatternImplication -> Pattern
+ Hydra: [patternImplicationConsequent] :: PatternImplication -> Pattern
+ Hydra: [primitiveDefinitionDefaultImplementation] :: PrimitiveDefinition -> Maybe Term
+ Hydra: [primitiveDefinitionIsPure] :: PrimitiveDefinition -> Bool
+ Hydra: [primitiveDefinitionIsTotal] :: PrimitiveDefinition -> Bool
+ Hydra: [primitiveDefinitionMetadata] :: PrimitiveDefinition -> Maybe EntityMetadata
+ Hydra: [primitiveDefinitionName] :: PrimitiveDefinition -> Name
+ Hydra: [primitiveDefinitionSignature] :: PrimitiveDefinition -> TermSignature
+ Hydra: [primitiveDefinition] :: Primitive -> PrimitiveDefinition
+ Hydra: [primitiveImplementation] :: Primitive -> Graph -> [Term] -> Either Error Term
+ Hydra: [primitiveReferenceName] :: PrimitiveReference -> Name
+ Hydra: [primitiveReferenceType] :: PrimitiveReference -> Type
+ Hydra: [projectionFieldName] :: Projection -> Name
+ Hydra: [projectionTypeName] :: Projection -> Name
+ Hydra: [provisionKind] :: Provision -> ProvisionKind
+ Hydra: [provisionName] :: Provision -> Name
+ Hydra: [provisionStatement] :: Provision -> String
+ Hydra: [qualifiedNameLocal] :: QualifiedName -> String
+ Hydra: [qualifiedNameModuleName] :: QualifiedName -> Maybe ModuleName
+ Hydra: [queryPatterns] :: Query -> [Pattern]
+ Hydra: [queryVariables] :: Query -> [Variable]
+ Hydra: [rangeMax] :: Range -> Int
+ Hydra: [rangeMin] :: Range -> Int
+ Hydra: [recordFields] :: Record -> [Field]
+ Hydra: [recordTypeName] :: Record -> Name
+ Hydra: [redundantWrapUnwrapErrorLocation] :: RedundantWrapUnwrapError -> SubtermPath
+ Hydra: [redundantWrapUnwrapErrorTypeName] :: RedundantWrapUnwrapError -> Name
+ Hydra: [regexSequencePath] :: RegexSequence -> Path
+ Hydra: [regexSequenceQuantifier] :: RegexSequence -> RegexQuantifier
+ Hydra: [relationSchemaColumns] :: RelationSchema t -> [ColumnSchema t]
+ Hydra: [relationSchemaForeignKeys] :: RelationSchema t -> [ForeignKey]
+ Hydra: [relationSchemaName] :: RelationSchema t -> RelationName
+ Hydra: [relationSchemaPrimaryKeys] :: RelationSchema t -> [PrimaryKey]
+ Hydra: [resultDescription] :: Result -> Maybe String
+ Hydra: [resultType] :: Result -> Type
+ Hydra: [selfApplicationErrorLocation] :: SelfApplicationError -> SubtermPath
+ Hydra: [selfApplicationErrorName] :: SelfApplicationError -> Name
+ Hydra: [singleVariantUnionErrorFieldName] :: SingleVariantUnionError -> Name
+ Hydra: [singleVariantUnionErrorLocation] :: SingleVariantUnionError -> SubtermPath
+ Hydra: [subtermLinkChild] :: SubtermLink -> TermNode
+ Hydra: [subtermLinkStep] :: SubtermLink -> SubtermStep
+ Hydra: [subtypeLinkChild] :: SubtypeLink -> TypeNode
+ Hydra: [subtypeLinkStep] :: SubtypeLink -> SubtypeStep
+ Hydra: [tableData] :: Table v -> [DataRow v]
+ Hydra: [tableHeader] :: Table v -> Maybe HeaderRow
+ Hydra: [tableTypeColumns] :: TableType -> [ColumnType]
+ Hydra: [tableTypeName] :: TableType -> RelationName
+ Hydra: [termCoderDecode] :: TermCoder a -> InferenceContext -> a -> Either Error Term
+ Hydra: [termCoderEncode] :: TermCoder a -> InferenceContext -> Graph -> Term -> Either Error a
+ Hydra: [termCoderType] :: TermCoder a -> Type
+ Hydra: [termDefinitionBody] :: TermDefinition -> Term
+ Hydra: [termDefinitionMetadata] :: TermDefinition -> Maybe EntityMetadata
+ Hydra: [termDefinitionName] :: TermDefinition -> Name
+ Hydra: [termDefinitionSignature] :: TermDefinition -> Maybe TermSignature
+ Hydra: [termGraphRoots] :: TermGraph -> Map Name TermNode
+ Hydra: [termNodeIdPath] :: TermNodeId -> SubtermPath
+ Hydra: [termNodeIdRoot] :: TermNodeId -> Name
+ Hydra: [termNodeLinks] :: TermNode -> [TermLink]
+ Hydra: [termNodeTerm] :: TermNode -> Term
+ Hydra: [termNodeType] :: TermNode -> Type
+ Hydra: [termReferenceLinkStep] :: TermReferenceLink -> SubtermStep
+ Hydra: [termReferenceLinkTarget] :: TermReferenceLink -> TermReference
+ Hydra: [termSignatureParameters] :: TermSignature -> [Parameter]
+ Hydra: [termSignatureResult] :: TermSignature -> Result
+ Hydra: [termSignatureTypeParameters] :: TermSignature -> [TypeParameter]
+ Hydra: [termVariableShadowingErrorLocation] :: TermVariableShadowingError -> SubtermPath
+ Hydra: [termVariableShadowingErrorName] :: TermVariableShadowingError -> Name
+ Hydra: [testCaseWithMetadataCase] :: TestCaseWithMetadata -> TestCase
+ Hydra: [testCaseWithMetadataDescription] :: TestCaseWithMetadata -> Maybe String
+ Hydra: [testCaseWithMetadataName] :: TestCaseWithMetadata -> String
+ Hydra: [testCaseWithMetadataProvisions] :: TestCaseWithMetadata -> [Name]
+ Hydra: [testCaseWithMetadataTags] :: TestCaseWithMetadata -> [Tag]
+ Hydra: [testGroupCases] :: TestGroup -> [TestCaseWithMetadata]
+ Hydra: [testGroupDescription] :: TestGroup -> Maybe String
+ Hydra: [testGroupName] :: TestGroup -> String
+ Hydra: [testGroupSubgroups] :: TestGroup -> [TestGroup]
+ Hydra: [triplePatternObject] :: TriplePattern -> Node
+ Hydra: [triplePatternPredicate] :: TriplePattern -> Path
+ Hydra: [triplePatternSubject] :: TriplePattern -> Node
+ Hydra: [typeApplicationTermBody] :: TypeApplicationTerm -> Term
+ Hydra: [typeApplicationTermType] :: TypeApplicationTerm -> Type
+ Hydra: [typeArityMismatchErrorActualArity] :: TypeArityMismatchError -> Int
+ Hydra: [typeArityMismatchErrorExpectedArity] :: TypeArityMismatchError -> Int
+ Hydra: [typeArityMismatchErrorTypeArguments] :: TypeArityMismatchError -> [Type]
+ Hydra: [typeArityMismatchErrorType] :: TypeArityMismatchError -> Type
+ Hydra: [typeClassDescription] :: TypeClass -> String
+ Hydra: [typeConstraintComment] :: TypeConstraint -> String
+ Hydra: [typeConstraintLeft] :: TypeConstraint -> Type
+ Hydra: [typeConstraintRight] :: TypeConstraint -> Type
+ Hydra: [typeDefinitionBody] :: TypeDefinition -> TypeScheme
+ Hydra: [typeDefinitionMetadata] :: TypeDefinition -> Maybe EntityMetadata
+ Hydra: [typeDefinitionName] :: TypeDefinition -> Name
+ Hydra: [typeGraphRoots] :: TypeGraph -> Map Name TypeNode
+ Hydra: [typeLambdaBody] :: TypeLambda -> Term
+ Hydra: [typeLambdaParameter] :: TypeLambda -> Name
+ Hydra: [typeMismatchErrorActualType] :: TypeMismatchError -> Type
+ Hydra: [typeMismatchErrorExpectedType] :: TypeMismatchError -> Type
+ Hydra: [typeNodeIdPath] :: TypeNodeId -> SubtypePath
+ Hydra: [typeNodeIdRoot] :: TypeNodeId -> Name
+ Hydra: [typeNodeLinks] :: TypeNode -> [TypeLink]
+ Hydra: [typeNodeType] :: TypeNode -> Type
+ Hydra: [typeParameterConstraints] :: TypeParameter -> [TypeClassConstraint]
+ Hydra: [typeParameterName] :: TypeParameter -> Name
+ Hydra: [typeReferenceLinkStep] :: TypeReferenceLink -> SubtypeStep
+ Hydra: [typeReferenceLinkTarget] :: TypeReferenceLink -> TypeReference
+ Hydra: [typeSchemeBody] :: TypeScheme -> Type
+ Hydra: [typeSchemeConstraints] :: TypeScheme -> Map Name TypeVariableConstraints
+ Hydra: [typeSchemeVariables] :: TypeScheme -> [Name]
+ Hydra: [typeVariableConstraintsClasses] :: TypeVariableConstraints -> Set TypeClassConstraint
+ Hydra: [typeVariableReferenceBoundByNode] :: TypeVariableReference -> TypeNodeId
+ Hydra: [typeVariableReferenceVariable] :: TypeVariableReference -> Name
+ Hydra: [typeVariableShadowingInForallErrorLocation] :: TypeVariableShadowingInForallError -> SubtermPath
+ Hydra: [typeVariableShadowingInForallErrorName] :: TypeVariableShadowingInForallError -> Name
+ Hydra: [typeVariableShadowingInTypeLambdaErrorLocation] :: TypeVariableShadowingInTypeLambdaError -> SubtermPath
+ Hydra: [typeVariableShadowingInTypeLambdaErrorName] :: TypeVariableShadowingInTypeLambdaError -> Name
+ Hydra: [typedBindingName] :: TypedBinding a -> Name
+ Hydra: [typedBindingTerm] :: TypedBinding a -> TypedTerm a
+ Hydra: [typedTermDefinitionName] :: TypedTermDefinition a -> Name
+ Hydra: [typedTermDefinitionTerm] :: TypedTermDefinition a -> TypedTerm a
+ Hydra: [unColumnName] :: ColumnName -> String
+ Hydra: [unDataRow] :: DataRow v -> [Maybe v]
+ Hydra: [unDecodingError] :: DecodingError -> String
+ Hydra: [unHeaderRow] :: HeaderRow -> [String]
+ Hydra: [unLanguageName] :: LanguageName -> String
+ Hydra: [unModuleName] :: ModuleName -> String
+ Hydra: [unName] :: Name -> String
+ Hydra: [unOtherError] :: OtherError -> String
+ Hydra: [unOtherResolutionError] :: OtherResolutionError -> String
+ Hydra: [unPackageName] :: PackageName -> String
+ Hydra: [unParser] :: Parser a -> [Int] -> ParseResult a
+ Hydra: [unPrimaryKey] :: PrimaryKey -> [ColumnName]
+ Hydra: [unRelationName] :: RelationName -> String
+ Hydra: [unRelation] :: Relation v -> [Row v]
+ Hydra: [unRelationship] :: Relationship v -> Set (Map ColumnName v)
+ Hydra: [unRow] :: Row v -> [v]
+ Hydra: [unSubtermPath] :: SubtermPath -> [SubtermStep]
+ Hydra: [unSubtypePath] :: SubtypePath -> [SubtypeStep]
+ Hydra: [unTag] :: Tag -> String
+ Hydra: [unTermSubst] :: TermSubst -> Map Name Term
+ Hydra: [unTypeSubst] :: TypeSubst -> Map Name Type
+ Hydra: [unTypedName] :: TypedName a -> Name
+ Hydra: [unTypedTerm] :: TypedTerm a -> Term
+ Hydra: [unVariable] :: Variable -> String
+ Hydra: [unVersion] :: Version -> String
+ Hydra: [unboundTypeVariablesErrorType] :: UnboundTypeVariablesError -> Type
+ Hydra: [unboundTypeVariablesErrorVariables] :: UnboundTypeVariablesError -> Set Name
+ Hydra: [undeclaredVariantErrorLocation] :: UndeclaredVariantError -> SubtermPath
+ Hydra: [undeclaredVariantErrorTypeName] :: UndeclaredVariantError -> Name
+ Hydra: [undeclaredVariantErrorVariantName] :: UndeclaredVariantError -> Name
+ Hydra: [undefinedFieldErrorFieldName] :: UndefinedFieldError -> Name
+ Hydra: [undefinedFieldErrorTypeName] :: UndefinedFieldError -> Name
+ Hydra: [undefinedTermVariableCheckingErrorName] :: UndefinedTermVariableCheckingError -> Name
+ Hydra: [undefinedTermVariableCheckingErrorPath] :: UndefinedTermVariableCheckingError -> SubtermPath
+ Hydra: [undefinedTermVariableErrorLocation] :: UndefinedTermVariableError -> SubtermPath
+ Hydra: [undefinedTermVariableErrorName] :: UndefinedTermVariableError -> Name
+ Hydra: [undefinedTypeVariableErrorLocation] :: UndefinedTypeVariableError -> SubtermPath
+ Hydra: [undefinedTypeVariableErrorName] :: UndefinedTypeVariableError -> Name
+ Hydra: [undefinedTypeVariableInBindingTypeErrorLocation] :: UndefinedTypeVariableInBindingTypeError -> SubtermPath
+ Hydra: [undefinedTypeVariableInBindingTypeErrorName] :: UndefinedTypeVariableInBindingTypeError -> Name
+ Hydra: [undefinedTypeVariableInLambdaDomainErrorLocation] :: UndefinedTypeVariableInLambdaDomainError -> SubtermPath
+ Hydra: [undefinedTypeVariableInLambdaDomainErrorName] :: UndefinedTypeVariableInLambdaDomainError -> Name
+ Hydra: [undefinedTypeVariableInTypeApplicationErrorLocation] :: UndefinedTypeVariableInTypeApplicationError -> SubtermPath
+ Hydra: [undefinedTypeVariableInTypeApplicationErrorName] :: UndefinedTypeVariableInTypeApplicationError -> Name
+ Hydra: [unequalTypesErrorDescription] :: UnequalTypesError -> String
+ Hydra: [unequalTypesErrorTypes] :: UnequalTypesError -> [Type]
+ Hydra: [unexpectedShapeErrorActual] :: UnexpectedShapeError -> String
+ Hydra: [unexpectedShapeErrorExpected] :: UnexpectedShapeError -> String
+ Hydra: [unexpectedTermVariantErrorActualTerm] :: UnexpectedTermVariantError -> Term
+ Hydra: [unexpectedTermVariantErrorExpectedVariant] :: UnexpectedTermVariantError -> TermVariant
+ Hydra: [unexpectedTypeVariantErrorActualType] :: UnexpectedTypeVariantError -> Type
+ Hydra: [unexpectedTypeVariantErrorExpectedVariant] :: UnexpectedTypeVariantError -> TypeVariant
+ Hydra: [unificationErrorLeftType] :: UnificationError -> Type
+ Hydra: [unificationErrorMessage] :: UnificationError -> String
+ Hydra: [unificationErrorRightType] :: UnificationError -> Type
+ Hydra: [unificationInferenceErrorCause] :: UnificationInferenceError -> UnificationError
+ Hydra: [unificationInferenceErrorPath] :: UnificationInferenceError -> SubtermPath
+ Hydra: [universalTestCaseActual] :: UniversalTestCase -> () -> String
+ Hydra: [universalTestCaseExpected] :: UniversalTestCase -> () -> String
+ Hydra: [unknownCaseAlternativeErrorLocation] :: UnknownCaseAlternativeError -> SubtermPath
+ Hydra: [unknownCaseAlternativeErrorName] :: UnknownCaseAlternativeError -> Name
+ Hydra: [unknownCaseAlternativeErrorTypeName] :: UnknownCaseAlternativeError -> Name
+ Hydra: [unknownPrimitiveNameErrorLocation] :: UnknownPrimitiveNameError -> SubtermPath
+ Hydra: [unknownPrimitiveNameErrorName] :: UnknownPrimitiveNameError -> Name
+ Hydra: [unknownProjectedFieldErrorFieldName] :: UnknownProjectedFieldError -> Name
+ Hydra: [unknownProjectedFieldErrorLocation] :: UnknownProjectedFieldError -> SubtermPath
+ Hydra: [unknownProjectedFieldErrorTypeName] :: UnknownProjectedFieldError -> Name
+ Hydra: [unnecessaryIdentityApplicationErrorLocation] :: UnnecessaryIdentityApplicationError -> SubtermPath
+ Hydra: [unresolvedNominalTypeErrorLocation] :: UnresolvedNominalTypeError -> SubtermPath
+ Hydra: [unresolvedNominalTypeErrorTypeName] :: UnresolvedNominalTypeError -> Name
+ Hydra: [unsupportedTermVariantErrorTermVariant] :: UnsupportedTermVariantError -> TermVariant
+ Hydra: [untypedLetBindingErrorBinding] :: UntypedLetBindingError -> Binding
+ Hydra: [untypedTermVariableCheckingErrorName] :: UntypedTermVariableCheckingError -> Name
+ Hydra: [untypedTermVariableCheckingErrorPath] :: UntypedTermVariableCheckingError -> SubtermPath
+ Hydra: [untypedTermVariableErrorLocation] :: UntypedTermVariableError -> SubtermPath
+ Hydra: [untypedTermVariableErrorName] :: UntypedTermVariableError -> Name
+ Hydra: [validationProfileErrorRules] :: ValidationProfile -> Set Name
+ Hydra: [validationProfileMaxErrors] :: ValidationProfile -> Int
+ Hydra: [validationProfileMaxWarnings] :: ValidationProfile -> Int
+ Hydra: [validationProfileWarningRules] :: ValidationProfile -> Set Name
+ Hydra: [validationResultErrors] :: ValidationResult e -> [e]
+ Hydra: [validationResultWarnings] :: ValidationResult e -> [e]
+ Hydra: [versionRangeLowerInclusive] :: VersionRange -> Maybe Version
+ Hydra: [versionRangeUpperExclusive] :: VersionRange -> Maybe Version
+ Hydra: [voidInNonBottomPositionErrorLocation] :: VoidInNonBottomPositionError -> SubtermPath
+ Hydra: [wrappedTermBody] :: WrappedTerm -> Term
+ Hydra: [wrappedTermTypeName] :: WrappedTerm -> Name
+ Hydra: _Adapter :: Name
+ Hydra: _AdapterContext :: Name
+ Hydra: _AdapterContext_adapters :: Name
+ Hydra: _AdapterContext_graph :: Name
+ Hydra: _AdapterContext_language :: Name
+ Hydra: _Adapter_coder :: Name
+ Hydra: _Adapter_isLossy :: Name
+ Hydra: _Adapter_source :: Name
+ Hydra: _Adapter_target :: Name
+ Hydra: _AnnotatedTerm :: Name
+ Hydra: _AnnotatedTerm_annotation :: Name
+ Hydra: _AnnotatedTerm_body :: Name
+ Hydra: _AnnotatedType :: Name
+ Hydra: _AnnotatedType_annotation :: Name
+ Hydra: _AnnotatedType_body :: Name
+ Hydra: _Application :: Name
+ Hydra: _ApplicationType :: Name
+ Hydra: _ApplicationType_argument :: Name
+ Hydra: _ApplicationType_function :: Name
+ Hydra: _Application_argument :: Name
+ Hydra: _Application_function :: Name
+ Hydra: _Bicoder :: Name
+ Hydra: _Bicoder_decode :: Name
+ Hydra: _Bicoder_encode :: Name
+ Hydra: _Binding :: Name
+ Hydra: _Binding_name :: Name
+ Hydra: _Binding_term :: Name
+ Hydra: _Binding_typeScheme :: Name
+ Hydra: _CaseAlternative :: Name
+ Hydra: _CaseAlternative_handler :: Name
+ Hydra: _CaseAlternative_name :: Name
+ Hydra: _CaseConvention :: Name
+ Hydra: _CaseConvention_camel :: Name
+ Hydra: _CaseConvention_lowerSnake :: Name
+ Hydra: _CaseConvention_pascal :: Name
+ Hydra: _CaseConvention_upperDashed :: Name
+ Hydra: _CaseConvention_upperSnake :: Name
+ Hydra: _CaseConventions :: Name
+ Hydra: _CaseConventions_constant :: Name
+ Hydra: _CaseConventions_directory :: Name
+ Hydra: _CaseConventions_enumValue :: Name
+ Hydra: _CaseConventions_field :: Name
+ Hydra: _CaseConventions_file :: Name
+ Hydra: _CaseConventions_module :: Name
+ Hydra: _CaseConventions_term :: Name
+ Hydra: _CaseConventions_termVariable :: Name
+ Hydra: _CaseConventions_type :: Name
+ Hydra: _CaseConventions_typeVariable :: Name
+ Hydra: _CaseStatement :: Name
+ Hydra: _CaseStatement_cases :: Name
+ Hydra: _CaseStatement_default :: Name
+ Hydra: _CaseStatement_typeName :: Name
+ Hydra: _CheckingError :: Name
+ Hydra: _CheckingError_incorrectUnification :: Name
+ Hydra: _CheckingError_notAForallType :: Name
+ Hydra: _CheckingError_notAFunctionType :: Name
+ Hydra: _CheckingError_other :: Name
+ Hydra: _CheckingError_typeArityMismatch :: Name
+ Hydra: _CheckingError_typeMismatch :: Name
+ Hydra: _CheckingError_unboundTypeVariables :: Name
+ Hydra: _CheckingError_undefinedTermVariable :: Name
+ Hydra: _CheckingError_unequalTypes :: Name
+ Hydra: _CheckingError_unsupportedTermVariant :: Name
+ Hydra: _CheckingError_untypedLambda :: Name
+ Hydra: _CheckingError_untypedLetBinding :: Name
+ Hydra: _CheckingError_untypedTermVariable :: Name
+ Hydra: _Coder :: Name
+ Hydra: _CoderDirection :: Name
+ Hydra: _CoderDirection_decode :: Name
+ Hydra: _CoderDirection_encode :: Name
+ Hydra: _Coder_decode :: Name
+ Hydra: _Coder_encode :: Name
+ Hydra: _ColumnName :: Name
+ Hydra: _ColumnSchema :: Name
+ Hydra: _ColumnSchema_domain :: Name
+ Hydra: _ColumnSchema_name :: Name
+ Hydra: _ColumnType :: Name
+ Hydra: _ColumnType_name :: Name
+ Hydra: _ColumnType_type :: Name
+ Hydra: _Comparison :: Name
+ Hydra: _ComparisonConstraint :: Name
+ Hydra: _ComparisonConstraint_equal :: Name
+ Hydra: _ComparisonConstraint_greaterThan :: Name
+ Hydra: _ComparisonConstraint_greaterThanOrEqual :: Name
+ Hydra: _ComparisonConstraint_lessThan :: Name
+ Hydra: _ComparisonConstraint_lessThanOrEqual :: Name
+ Hydra: _ComparisonConstraint_notEqual :: Name
+ Hydra: _Comparison_equalTo :: Name
+ Hydra: _Comparison_greaterThan :: Name
+ Hydra: _Comparison_lessThan :: Name
+ Hydra: _ConstantConditionError :: Name
+ Hydra: _ConstantConditionError_location :: Name
+ Hydra: _ConstantConditionError_value :: Name
+ Hydra: _DataRow :: Name
+ Hydra: _DecodingError :: Name
+ Hydra: _Definition :: Name
+ Hydra: _DefinitionReference :: Name
+ Hydra: _DefinitionReference_primitive :: Name
+ Hydra: _DefinitionReference_term :: Name
+ Hydra: _DefinitionReference_type :: Name
+ Hydra: _Definition_primitive :: Name
+ Hydra: _Definition_term :: Name
+ Hydra: _Definition_type :: Name
+ Hydra: _DependencyScope :: Name
+ Hydra: _DependencyScope_api :: Name
+ Hydra: _DependencyScope_runtime :: Name
+ Hydra: _DependencyScope_test :: Name
+ Hydra: _DependencyScope_tool :: Name
+ Hydra: _DuplicateBindingError :: Name
+ Hydra: _DuplicateBindingError_location :: Name
+ Hydra: _DuplicateBindingError_name :: Name
+ Hydra: _DuplicateFieldError :: Name
+ Hydra: _DuplicateFieldError_location :: Name
+ Hydra: _DuplicateFieldError_name :: Name
+ Hydra: _DuplicateRecordTypeFieldNamesError :: Name
+ Hydra: _DuplicateRecordTypeFieldNamesError_location :: Name
+ Hydra: _DuplicateRecordTypeFieldNamesError_name :: Name
+ Hydra: _DuplicateUnionTypeFieldNamesError :: Name
+ Hydra: _DuplicateUnionTypeFieldNamesError_location :: Name
+ Hydra: _DuplicateUnionTypeFieldNamesError_name :: Name
+ Hydra: _Edge :: Name
+ Hydra: _Edge_in :: Name
+ Hydra: _Edge_out :: Name
+ Hydra: _Edge_type :: Name
+ Hydra: _EffectfulTestCase :: Name
+ Hydra: _EffectfulTestCase_actual :: Name
+ Hydra: _EffectfulTestCase_expected :: Name
+ Hydra: _EitherType :: Name
+ Hydra: _EitherType_left :: Name
+ Hydra: _EitherType_right :: Name
+ Hydra: _EmptyCaseStatementError :: Name
+ Hydra: _EmptyCaseStatementError_location :: Name
+ Hydra: _EmptyCaseStatementError_typeName :: Name
+ Hydra: _EmptyLetBindingsError :: Name
+ Hydra: _EmptyLetBindingsError_location :: Name
+ Hydra: _EmptyListError :: Name
+ Hydra: _EmptyRecordTypeError :: Name
+ Hydra: _EmptyRecordTypeError_location :: Name
+ Hydra: _EmptyTermAnnotationError :: Name
+ Hydra: _EmptyTermAnnotationError_location :: Name
+ Hydra: _EmptyTypeAnnotationError :: Name
+ Hydra: _EmptyTypeAnnotationError_location :: Name
+ Hydra: _EmptyTypeNameInTermError :: Name
+ Hydra: _EmptyTypeNameInTermError_location :: Name
+ Hydra: _EmptyUnionTypeError :: Name
+ Hydra: _EmptyUnionTypeError_location :: Name
+ Hydra: _EntityMetadata :: Name
+ Hydra: _EntityMetadata_comments :: Name
+ Hydra: _EntityMetadata_description :: Name
+ Hydra: _EntityMetadata_lifecycle :: Name
+ Hydra: _EntityMetadata_provisions :: Name
+ Hydra: _EntityMetadata_seeAlso :: Name
+ Hydra: _EntityReference :: Name
+ Hydra: _EntityReference_definition :: Name
+ Hydra: _EntityReference_module :: Name
+ Hydra: _EntityReference_package :: Name
+ Hydra: _EntityReference_termExpr :: Name
+ Hydra: _EntityReference_typeExpr :: Name
+ Hydra: _Error :: Name
+ Hydra: _Error_checking :: Name
+ Hydra: _Error_decoding :: Name
+ Hydra: _Error_duplicateBinding :: Name
+ Hydra: _Error_duplicateField :: Name
+ Hydra: _Error_extraction :: Name
+ Hydra: _Error_inference :: Name
+ Hydra: _Error_invalidLiteral :: Name
+ Hydra: _Error_other :: Name
+ Hydra: _Error_resolution :: Name
+ Hydra: _Error_undefinedField :: Name
+ Hydra: _Error_undefinedTermVariable :: Name
+ Hydra: _Error_unexpectedTermVariant :: Name
+ Hydra: _Error_unexpectedTypeVariant :: Name
+ Hydra: _Error_unification :: Name
+ Hydra: _Error_untypedTermVariable :: Name
+ Hydra: _ExtraRecordFieldsError :: Name
+ Hydra: _ExtraRecordFieldsError_fieldNames :: Name
+ Hydra: _ExtraRecordFieldsError_location :: Name
+ Hydra: _ExtraRecordFieldsError_typeName :: Name
+ Hydra: _ExtractionError :: Name
+ Hydra: _ExtractionError_emptyList :: Name
+ Hydra: _ExtractionError_multipleBindings :: Name
+ Hydra: _ExtractionError_multipleFields :: Name
+ Hydra: _ExtractionError_noMatchingField :: Name
+ Hydra: _ExtractionError_noSuchBinding :: Name
+ Hydra: _ExtractionError_notEnoughCases :: Name
+ Hydra: _ExtractionError_unexpectedShape :: Name
+ Hydra: _Field :: Name
+ Hydra: _FieldType :: Name
+ Hydra: _FieldType_name :: Name
+ Hydra: _FieldType_type :: Name
+ Hydra: _Field_name :: Name
+ Hydra: _Field_term :: Name
+ Hydra: _FloatType :: Name
+ Hydra: _FloatType_float32 :: Name
+ Hydra: _FloatType_float64 :: Name
+ Hydra: _FloatValue :: Name
+ Hydra: _FloatValue_float32 :: Name
+ Hydra: _FloatValue_float64 :: Name
+ Hydra: _ForallType :: Name
+ Hydra: _ForallType_body :: Name
+ Hydra: _ForallType_parameter :: Name
+ Hydra: _ForeignKey :: Name
+ Hydra: _ForeignKey_foreignRelation :: Name
+ Hydra: _ForeignKey_keys :: Name
+ Hydra: _FunctionStructure :: Name
+ Hydra: _FunctionStructure_bindings :: Name
+ Hydra: _FunctionStructure_body :: Name
+ Hydra: _FunctionStructure_codomain :: Name
+ Hydra: _FunctionStructure_domains :: Name
+ Hydra: _FunctionStructure_environment :: Name
+ Hydra: _FunctionStructure_params :: Name
+ Hydra: _FunctionStructure_typeParams :: Name
+ Hydra: _FunctionType :: Name
+ Hydra: _FunctionType_codomain :: Name
+ Hydra: _FunctionType_domain :: Name
+ Hydra: _Graph :: Name
+ Hydra: _GraphPattern :: Name
+ Hydra: _GraphPattern_graph :: Name
+ Hydra: _GraphPattern_patterns :: Name
+ Hydra: _Graph_boundTerms :: Name
+ Hydra: _Graph_boundTypes :: Name
+ Hydra: _Graph_classConstraints :: Name
+ Hydra: _Graph_lambdaVariables :: Name
+ Hydra: _Graph_metadata :: Name
+ Hydra: _Graph_primitives :: Name
+ Hydra: _Graph_schemaTypes :: Name
+ Hydra: _Graph_typeVariables :: Name
+ Hydra: _HeaderRow :: Name
+ Hydra: _IncorrectUnificationError :: Name
+ Hydra: _IncorrectUnificationError_substitution :: Name
+ Hydra: _InferenceContext :: Name
+ Hydra: _InferenceContext_freshTypeVariableCount :: Name
+ Hydra: _InferenceContext_trace :: Name
+ Hydra: _InferenceError :: Name
+ Hydra: _InferenceError_checking :: Name
+ Hydra: _InferenceError_other :: Name
+ Hydra: _InferenceError_unification :: Name
+ Hydra: _InferenceResult :: Name
+ Hydra: _InferenceResult_classConstraints :: Name
+ Hydra: _InferenceResult_context :: Name
+ Hydra: _InferenceResult_subst :: Name
+ Hydra: _InferenceResult_term :: Name
+ Hydra: _InferenceResult_type :: Name
+ Hydra: _Injection :: Name
+ Hydra: _Injection_field :: Name
+ Hydra: _Injection_typeName :: Name
+ Hydra: _IntegerType :: Name
+ Hydra: _IntegerType_bigint :: Name
+ Hydra: _IntegerType_int16 :: Name
+ Hydra: _IntegerType_int32 :: Name
+ Hydra: _IntegerType_int64 :: Name
+ Hydra: _IntegerType_int8 :: Name
+ Hydra: _IntegerType_uint16 :: Name
+ Hydra: _IntegerType_uint32 :: Name
+ Hydra: _IntegerType_uint64 :: Name
+ Hydra: _IntegerType_uint8 :: Name
+ Hydra: _IntegerValue :: Name
+ Hydra: _IntegerValue_bigint :: Name
+ Hydra: _IntegerValue_int16 :: Name
+ Hydra: _IntegerValue_int32 :: Name
+ Hydra: _IntegerValue_int64 :: Name
+ Hydra: _IntegerValue_int8 :: Name
+ Hydra: _IntegerValue_uint16 :: Name
+ Hydra: _IntegerValue_uint32 :: Name
+ Hydra: _IntegerValue_uint64 :: Name
+ Hydra: _IntegerValue_uint8 :: Name
+ Hydra: _InvalidForallParameterNameError :: Name
+ Hydra: _InvalidForallParameterNameError_location :: Name
+ Hydra: _InvalidForallParameterNameError_name :: Name
+ Hydra: _InvalidLambdaParameterNameError :: Name
+ Hydra: _InvalidLambdaParameterNameError_location :: Name
+ Hydra: _InvalidLambdaParameterNameError_name :: Name
+ Hydra: _InvalidLetBindingNameError :: Name
+ Hydra: _InvalidLetBindingNameError_location :: Name
+ Hydra: _InvalidLetBindingNameError_name :: Name
+ Hydra: _InvalidLiteralError :: Name
+ Hydra: _InvalidLiteralError_typeMismatch :: Name
+ Hydra: _InvalidTermError :: Name
+ Hydra: _InvalidTermError_constantCondition :: Name
+ Hydra: _InvalidTermError_duplicateBinding :: Name
+ Hydra: _InvalidTermError_duplicateField :: Name
+ Hydra: _InvalidTermError_emptyCaseStatement :: Name
+ Hydra: _InvalidTermError_emptyLetBindings :: Name
+ Hydra: _InvalidTermError_emptyTermAnnotation :: Name
+ Hydra: _InvalidTermError_emptyTypeNameInTerm :: Name
+ Hydra: _InvalidTermError_extraRecordFields :: Name
+ Hydra: _InvalidTermError_invalidLambdaParameterName :: Name
+ Hydra: _InvalidTermError_invalidLetBindingName :: Name
+ Hydra: _InvalidTermError_invalidTypeLambdaParameterName :: Name
+ Hydra: _InvalidTermError_missingCaseBranches :: Name
+ Hydra: _InvalidTermError_missingRecordFields :: Name
+ Hydra: _InvalidTermError_nestedTermAnnotation :: Name
+ Hydra: _InvalidTermError_nominalTypeKindMismatch :: Name
+ Hydra: _InvalidTermError_redundantWrapUnwrap :: Name
+ Hydra: _InvalidTermError_selfApplication :: Name
+ Hydra: _InvalidTermError_termVariableShadowing :: Name
+ Hydra: _InvalidTermError_typeVariableShadowingInTypeLambda :: Name
+ Hydra: _InvalidTermError_undeclaredVariant :: Name
+ Hydra: _InvalidTermError_undefinedTermVariable :: Name
+ Hydra: _InvalidTermError_undefinedTypeVariableInBindingType :: Name
+ Hydra: _InvalidTermError_undefinedTypeVariableInLambdaDomain :: Name
+ Hydra: _InvalidTermError_undefinedTypeVariableInTypeApplication :: Name
+ Hydra: _InvalidTermError_unknownCaseAlternative :: Name
+ Hydra: _InvalidTermError_unknownPrimitiveName :: Name
+ Hydra: _InvalidTermError_unknownProjectedField :: Name
+ Hydra: _InvalidTermError_unnecessaryIdentityApplication :: Name
+ Hydra: _InvalidTermError_unresolvedNominalType :: Name
+ Hydra: _InvalidTermError_untypedTermVariable :: Name
+ Hydra: _InvalidTypeError :: Name
+ Hydra: _InvalidTypeError_duplicateRecordTypeFieldNames :: Name
+ Hydra: _InvalidTypeError_duplicateUnionTypeFieldNames :: Name
+ Hydra: _InvalidTypeError_emptyRecordType :: Name
+ Hydra: _InvalidTypeError_emptyTypeAnnotation :: Name
+ Hydra: _InvalidTypeError_emptyUnionType :: Name
+ Hydra: _InvalidTypeError_invalidForallParameterName :: Name
+ Hydra: _InvalidTypeError_invalidTypeSchemeVariableName :: Name
+ Hydra: _InvalidTypeError_nestedTypeAnnotation :: Name
+ Hydra: _InvalidTypeError_nonComparableMapKeyType :: Name
+ Hydra: _InvalidTypeError_nonComparableSetElementType :: Name
+ Hydra: _InvalidTypeError_singleVariantUnion :: Name
+ Hydra: _InvalidTypeError_typeVariableShadowingInForall :: Name
+ Hydra: _InvalidTypeError_undefinedTypeVariable :: Name
+ Hydra: _InvalidTypeError_voidInNonBottomPosition :: Name
+ Hydra: _InvalidTypeLambdaParameterNameError :: Name
+ Hydra: _InvalidTypeLambdaParameterNameError_location :: Name
+ Hydra: _InvalidTypeLambdaParameterNameError_name :: Name
+ Hydra: _InvalidTypeSchemeVariableNameError :: Name
+ Hydra: _InvalidTypeSchemeVariableNameError_location :: Name
+ Hydra: _InvalidTypeSchemeVariableNameError_name :: Name
+ Hydra: _Lambda :: Name
+ Hydra: _LambdaVariableReference :: Name
+ Hydra: _LambdaVariableReference_boundByNode :: Name
+ Hydra: _LambdaVariableReference_type :: Name
+ Hydra: _LambdaVariableReference_variable :: Name
+ Hydra: _Lambda_body :: Name
+ Hydra: _Lambda_domain :: Name
+ Hydra: _Lambda_parameter :: Name
+ Hydra: _Language :: Name
+ Hydra: _LanguageConstraints :: Name
+ Hydra: _LanguageConstraints_floatTypes :: Name
+ Hydra: _LanguageConstraints_integerTypes :: Name
+ Hydra: _LanguageConstraints_literalVariants :: Name
+ Hydra: _LanguageConstraints_termVariants :: Name
+ Hydra: _LanguageConstraints_typeVariants :: Name
+ Hydra: _LanguageConstraints_types :: Name
+ Hydra: _LanguageFeature :: Name
+ Hydra: _LanguageFeature_nestedCaseStatements :: Name
+ Hydra: _LanguageFeature_nestedPolymorphicLetBindings :: Name
+ Hydra: _LanguageFeature_partialApplication :: Name
+ Hydra: _LanguageName :: Name
+ Hydra: _Language_caseConventions :: Name
+ Hydra: _Language_constraints :: Name
+ Hydra: _Language_defaultFileExtension :: Name
+ Hydra: _Language_name :: Name
+ Hydra: _Language_supportedFeatures :: Name
+ Hydra: _Let :: Name
+ Hydra: _LetVariableReference :: Name
+ Hydra: _LetVariableReference_bindingNode :: Name
+ Hydra: _LetVariableReference_type :: Name
+ Hydra: _LetVariableReference_variable :: Name
+ Hydra: _Let_bindings :: Name
+ Hydra: _Let_body :: Name
+ Hydra: _Library :: Name
+ Hydra: _Library_name :: Name
+ Hydra: _Library_prefix :: Name
+ Hydra: _Library_primitives :: Name
+ Hydra: _LifecycleInfo :: Name
+ Hydra: _LifecycleInfo_availableSince :: Name
+ Hydra: _LifecycleInfo_deprecatedSince :: Name
+ Hydra: _Literal :: Name
+ Hydra: _LiteralType :: Name
+ Hydra: _LiteralTypeMismatchError :: Name
+ Hydra: _LiteralTypeMismatchError_actualType :: Name
+ Hydra: _LiteralTypeMismatchError_expectedType :: Name
+ Hydra: _LiteralType_binary :: Name
+ Hydra: _LiteralType_boolean :: Name
+ Hydra: _LiteralType_decimal :: Name
+ Hydra: _LiteralType_float :: Name
+ Hydra: _LiteralType_integer :: Name
+ Hydra: _LiteralType_string :: Name
+ Hydra: _LiteralVariant :: Name
+ Hydra: _LiteralVariant_binary :: Name
+ Hydra: _LiteralVariant_boolean :: Name
+ Hydra: _LiteralVariant_decimal :: Name
+ Hydra: _LiteralVariant_float :: Name
+ Hydra: _LiteralVariant_integer :: Name
+ Hydra: _LiteralVariant_string :: Name
+ Hydra: _Literal_binary :: Name
+ Hydra: _Literal_boolean :: Name
+ Hydra: _Literal_decimal :: Name
+ Hydra: _Literal_float :: Name
+ Hydra: _Literal_integer :: Name
+ Hydra: _Literal_string :: Name
+ Hydra: _MapType :: Name
+ Hydra: _MapType_keys :: Name
+ Hydra: _MapType_values :: Name
+ Hydra: _MissingCaseBranchesError :: Name
+ Hydra: _MissingCaseBranchesError_location :: Name
+ Hydra: _MissingCaseBranchesError_typeName :: Name
+ Hydra: _MissingCaseBranchesError_variantNames :: Name
+ Hydra: _MissingRecordFieldsError :: Name
+ Hydra: _MissingRecordFieldsError_fieldNames :: Name
+ Hydra: _MissingRecordFieldsError_location :: Name
+ Hydra: _MissingRecordFieldsError_typeName :: Name
+ Hydra: _Module :: Name
+ Hydra: _ModuleDependency :: Name
+ Hydra: _ModuleDependency_module :: Name
+ Hydra: _ModuleDependency_package :: Name
+ Hydra: _ModuleName :: Name
+ Hydra: _ModuleNames :: Name
+ Hydra: _ModuleNames_focus :: Name
+ Hydra: _ModuleNames_mapping :: Name
+ Hydra: _Module_definitions :: Name
+ Hydra: _Module_dependencies :: Name
+ Hydra: _Module_metadata :: Name
+ Hydra: _Module_name :: Name
+ Hydra: _MultipleBindingsError :: Name
+ Hydra: _MultipleBindingsError_name :: Name
+ Hydra: _MultipleFieldsError :: Name
+ Hydra: _MultipleFieldsError_fieldName :: Name
+ Hydra: _Name :: Name
+ Hydra: _NestedTermAnnotationError :: Name
+ Hydra: _NestedTermAnnotationError_location :: Name
+ Hydra: _NestedTypeAnnotationError :: Name
+ Hydra: _NestedTypeAnnotationError_location :: Name
+ Hydra: _NoMatchingFieldError :: Name
+ Hydra: _NoMatchingFieldError_fieldName :: Name
+ Hydra: _NoSuchBindingError :: Name
+ Hydra: _NoSuchBindingError_name :: Name
+ Hydra: _NoSuchPrimitiveError :: Name
+ Hydra: _NoSuchPrimitiveError_name :: Name
+ Hydra: _Node :: Name
+ Hydra: _Node_term :: Name
+ Hydra: _Node_variable :: Name
+ Hydra: _Node_wildcard :: Name
+ Hydra: _NominalTypeKindMismatchError :: Name
+ Hydra: _NominalTypeKindMismatchError_actualVariant :: Name
+ Hydra: _NominalTypeKindMismatchError_expectedVariant :: Name
+ Hydra: _NominalTypeKindMismatchError_location :: Name
+ Hydra: _NominalTypeKindMismatchError_typeName :: Name
+ Hydra: _NominalTypeReference :: Name
+ Hydra: _NominalTypeReference_name :: Name
+ Hydra: _NonComparableMapKeyTypeError :: Name
+ Hydra: _NonComparableMapKeyTypeError_keyType :: Name
+ Hydra: _NonComparableMapKeyTypeError_location :: Name
+ Hydra: _NonComparableSetElementTypeError :: Name
+ Hydra: _NonComparableSetElementTypeError_elementType :: Name
+ Hydra: _NonComparableSetElementTypeError_location :: Name
+ Hydra: _NotAForallTypeError :: Name
+ Hydra: _NotAForallTypeError_type :: Name
+ Hydra: _NotAForallTypeError_typeArguments :: Name
+ Hydra: _NotAFunctionTypeError :: Name
+ Hydra: _NotAFunctionTypeError_type :: Name
+ Hydra: _NotEnoughCasesError :: Name
+ Hydra: _OtherCheckingError :: Name
+ Hydra: _OtherCheckingError_message :: Name
+ Hydra: _OtherCheckingError_path :: Name
+ Hydra: _OtherError :: Name
+ Hydra: _OtherInferenceError :: Name
+ Hydra: _OtherInferenceError_message :: Name
+ Hydra: _OtherInferenceError_path :: Name
+ Hydra: _OtherResolutionError :: Name
+ Hydra: _Package :: Name
+ Hydra: _PackageDependency :: Name
+ Hydra: _PackageDependency_name :: Name
+ Hydra: _PackageDependency_scope :: Name
+ Hydra: _PackageDependency_version :: Name
+ Hydra: _PackageName :: Name
+ Hydra: _Package_dependencies :: Name
+ Hydra: _Package_metadata :: Name
+ Hydra: _Package_modules :: Name
+ Hydra: _Package_name :: Name
+ Hydra: _PairType :: Name
+ Hydra: _PairType_first :: Name
+ Hydra: _PairType_second :: Name
+ Hydra: _Parameter :: Name
+ Hydra: _Parameter_description :: Name
+ Hydra: _Parameter_isLazy :: Name
+ Hydra: _Parameter_name :: Name
+ Hydra: _Parameter_type :: Name
+ Hydra: _ParseError :: Name
+ Hydra: _ParseError_message :: Name
+ Hydra: _ParseError_remainder :: Name
+ Hydra: _ParseResult :: Name
+ Hydra: _ParseResult_failure :: Name
+ Hydra: _ParseResult_success :: Name
+ Hydra: _ParseSuccess :: Name
+ Hydra: _ParseSuccess_remainder :: Name
+ Hydra: _ParseSuccess_value :: Name
+ Hydra: _Parser :: Name
+ Hydra: _Path :: Name
+ Hydra: _PathEquation :: Name
+ Hydra: _PathEquation_left :: Name
+ Hydra: _PathEquation_right :: Name
+ Hydra: _Path_inverse :: Name
+ Hydra: _Path_regex :: Name
+ Hydra: _Path_step :: Name
+ Hydra: _Pattern :: Name
+ Hydra: _PatternImplication :: Name
+ Hydra: _PatternImplication_antecedent :: Name
+ Hydra: _PatternImplication_consequent :: Name
+ Hydra: _Pattern_conjunction :: Name
+ Hydra: _Pattern_disjunction :: Name
+ Hydra: _Pattern_graph :: Name
+ Hydra: _Pattern_negation :: Name
+ Hydra: _Pattern_triple :: Name
+ Hydra: _Precision :: Name
+ Hydra: _Precision_arbitrary :: Name
+ Hydra: _Precision_bits :: Name
+ Hydra: _PrimaryKey :: Name
+ Hydra: _Primitive :: Name
+ Hydra: _PrimitiveDefinition :: Name
+ Hydra: _PrimitiveDefinition_defaultImplementation :: Name
+ Hydra: _PrimitiveDefinition_isPure :: Name
+ Hydra: _PrimitiveDefinition_isTotal :: Name
+ Hydra: _PrimitiveDefinition_metadata :: Name
+ Hydra: _PrimitiveDefinition_name :: Name
+ Hydra: _PrimitiveDefinition_signature :: Name
+ Hydra: _PrimitiveReference :: Name
+ Hydra: _PrimitiveReference_name :: Name
+ Hydra: _PrimitiveReference_type :: Name
+ Hydra: _Primitive_definition :: Name
+ Hydra: _Primitive_implementation :: Name
+ Hydra: _Projection :: Name
+ Hydra: _Projection_fieldName :: Name
+ Hydra: _Projection_typeName :: Name
+ Hydra: _Provision :: Name
+ Hydra: _ProvisionKind :: Name
+ Hydra: _ProvisionKind_recommendation :: Name
+ Hydra: _ProvisionKind_requirement :: Name
+ Hydra: _Provision_kind :: Name
+ Hydra: _Provision_name :: Name
+ Hydra: _Provision_statement :: Name
+ Hydra: _QualifiedName :: Name
+ Hydra: _QualifiedName_local :: Name
+ Hydra: _QualifiedName_moduleName :: Name
+ Hydra: _Query :: Name
+ Hydra: _Query_patterns :: Name
+ Hydra: _Query_variables :: Name
+ Hydra: _Range :: Name
+ Hydra: _Range_max :: Name
+ Hydra: _Range_min :: Name
+ Hydra: _Record :: Name
+ Hydra: _Record_fields :: Name
+ Hydra: _Record_typeName :: Name
+ Hydra: _RedundantWrapUnwrapError :: Name
+ Hydra: _RedundantWrapUnwrapError_location :: Name
+ Hydra: _RedundantWrapUnwrapError_typeName :: Name
+ Hydra: _RegexQuantifier :: Name
+ Hydra: _RegexQuantifier_atLeast :: Name
+ Hydra: _RegexQuantifier_exactly :: Name
+ Hydra: _RegexQuantifier_one :: Name
+ Hydra: _RegexQuantifier_oneOrMore :: Name
+ Hydra: _RegexQuantifier_range :: Name
+ Hydra: _RegexQuantifier_zeroOrMore :: Name
+ Hydra: _RegexQuantifier_zeroOrOne :: Name
+ Hydra: _RegexSequence :: Name
+ Hydra: _RegexSequence_path :: Name
+ Hydra: _RegexSequence_quantifier :: Name
+ Hydra: _Relation :: Name
+ Hydra: _RelationName :: Name
+ Hydra: _RelationSchema :: Name
+ Hydra: _RelationSchema_columns :: Name
+ Hydra: _RelationSchema_foreignKeys :: Name
+ Hydra: _RelationSchema_name :: Name
+ Hydra: _RelationSchema_primaryKeys :: Name
+ Hydra: _Relationship :: Name
+ Hydra: _ResolutionError :: Name
+ Hydra: _ResolutionError_noMatchingField :: Name
+ Hydra: _ResolutionError_noSuchBinding :: Name
+ Hydra: _ResolutionError_noSuchPrimitive :: Name
+ Hydra: _ResolutionError_other :: Name
+ Hydra: _ResolutionError_unexpectedShape :: Name
+ Hydra: _Result :: Name
+ Hydra: _Result_description :: Name
+ Hydra: _Result_type :: Name
+ Hydra: _Row :: Name
+ Hydra: _SelfApplicationError :: Name
+ Hydra: _SelfApplicationError_location :: Name
+ Hydra: _SelfApplicationError_name :: Name
+ Hydra: _SingleVariantUnionError :: Name
+ Hydra: _SingleVariantUnionError_fieldName :: Name
+ Hydra: _SingleVariantUnionError_location :: Name
+ Hydra: _Step :: Name
+ Hydra: _Step_compare :: Name
+ Hydra: _Step_edge :: Name
+ Hydra: _Step_project :: Name
+ Hydra: _SubtermLink :: Name
+ Hydra: _SubtermLink_child :: Name
+ Hydra: _SubtermLink_step :: Name
+ Hydra: _SubtermPath :: Name
+ Hydra: _SubtermStep :: Name
+ Hydra: _SubtermStep_annotatedAnnotation :: Name
+ Hydra: _SubtermStep_annotatedBody :: Name
+ Hydra: _SubtermStep_applicationArgument :: Name
+ Hydra: _SubtermStep_applicationFunction :: Name
+ Hydra: _SubtermStep_casesCase :: Name
+ Hydra: _SubtermStep_casesDefault :: Name
+ Hydra: _SubtermStep_eitherLeft :: Name
+ Hydra: _SubtermStep_eitherRight :: Name
+ Hydra: _SubtermStep_injectField :: Name
+ Hydra: _SubtermStep_lambdaBody :: Name
+ Hydra: _SubtermStep_letBinding :: Name
+ Hydra: _SubtermStep_letBody :: Name
+ Hydra: _SubtermStep_listElement :: Name
+ Hydra: _SubtermStep_mapEntry :: Name
+ Hydra: _SubtermStep_optionalGiven :: Name
+ Hydra: _SubtermStep_pairFirst :: Name
+ Hydra: _SubtermStep_pairSecond :: Name
+ Hydra: _SubtermStep_recordField :: Name
+ Hydra: _SubtermStep_setElement :: Name
+ Hydra: _SubtermStep_typeApplicationBody :: Name
+ Hydra: _SubtermStep_typeLambdaBody :: Name
+ Hydra: _SubtermStep_wrapBody :: Name
+ Hydra: _SubtypeLink :: Name
+ Hydra: _SubtypeLink_child :: Name
+ Hydra: _SubtypeLink_step :: Name
+ Hydra: _SubtypePath :: Name
+ Hydra: _SubtypeStep :: Name
+ Hydra: _SubtypeStep_annotatedBody :: Name
+ Hydra: _SubtypeStep_applicationArgument :: Name
+ Hydra: _SubtypeStep_applicationFunction :: Name
+ Hydra: _SubtypeStep_effectValue :: Name
+ Hydra: _SubtypeStep_eitherLeft :: Name
+ Hydra: _SubtypeStep_eitherRight :: Name
+ Hydra: _SubtypeStep_forallBody :: Name
+ Hydra: _SubtypeStep_functionCodomain :: Name
+ Hydra: _SubtypeStep_functionDomain :: Name
+ Hydra: _SubtypeStep_listElement :: Name
+ Hydra: _SubtypeStep_mapKeys :: Name
+ Hydra: _SubtypeStep_mapValues :: Name
+ Hydra: _SubtypeStep_optionalElement :: Name
+ Hydra: _SubtypeStep_pairFirst :: Name
+ Hydra: _SubtypeStep_pairSecond :: Name
+ Hydra: _SubtypeStep_recordField :: Name
+ Hydra: _SubtypeStep_setElement :: Name
+ Hydra: _SubtypeStep_unionField :: Name
+ Hydra: _SubtypeStep_wrapBody :: Name
+ Hydra: _SymmetricAdapter :: Name
+ Hydra: _Table :: Name
+ Hydra: _TableType :: Name
+ Hydra: _TableType_columns :: Name
+ Hydra: _TableType_name :: Name
+ Hydra: _Table_data :: Name
+ Hydra: _Table_header :: Name
+ Hydra: _Tag :: Name
+ Hydra: _Term :: Name
+ Hydra: _TermAttributeLink :: Name
+ Hydra: _TermAttributeLink_casesTypeName :: Name
+ Hydra: _TermAttributeLink_injectTypeName :: Name
+ Hydra: _TermAttributeLink_lambdaDomainGiven :: Name
+ Hydra: _TermAttributeLink_lambdaParameter :: Name
+ Hydra: _TermAttributeLink_letBindingTypeSchemeGiven :: Name
+ Hydra: _TermAttributeLink_literal :: Name
+ Hydra: _TermAttributeLink_projectFieldName :: Name
+ Hydra: _TermAttributeLink_projectTypeName :: Name
+ Hydra: _TermAttributeLink_recordTypeName :: Name
+ Hydra: _TermAttributeLink_typeApplicationType :: Name
+ Hydra: _TermAttributeLink_typeLambdaParameter :: Name
+ Hydra: _TermAttributeLink_unwrapTypeName :: Name
+ Hydra: _TermAttributeLink_wrapTypeName :: Name
+ Hydra: _TermCoder :: Name
+ Hydra: _TermCoder_decode :: Name
+ Hydra: _TermCoder_encode :: Name
+ Hydra: _TermCoder_type :: Name
+ Hydra: _TermDefinition :: Name
+ Hydra: _TermDefinition_body :: Name
+ Hydra: _TermDefinition_metadata :: Name
+ Hydra: _TermDefinition_name :: Name
+ Hydra: _TermDefinition_signature :: Name
+ Hydra: _TermGraph :: Name
+ Hydra: _TermGraph_roots :: Name
+ Hydra: _TermLink :: Name
+ Hydra: _TermLink_attribute :: Name
+ Hydra: _TermLink_reference :: Name
+ Hydra: _TermLink_subterm :: Name
+ Hydra: _TermNode :: Name
+ Hydra: _TermNodeId :: Name
+ Hydra: _TermNodeId_path :: Name
+ Hydra: _TermNodeId_root :: Name
+ Hydra: _TermNode_links :: Name
+ Hydra: _TermNode_term :: Name
+ Hydra: _TermNode_type :: Name
+ Hydra: _TermReference :: Name
+ Hydra: _TermReferenceLink :: Name
+ Hydra: _TermReferenceLink_step :: Name
+ Hydra: _TermReferenceLink_target :: Name
+ Hydra: _TermReference_lambda :: Name
+ Hydra: _TermReference_let :: Name
+ Hydra: _TermReference_primitive :: Name
+ Hydra: _TermSignature :: Name
+ Hydra: _TermSignature_parameters :: Name
+ Hydra: _TermSignature_result :: Name
+ Hydra: _TermSignature_typeParameters :: Name
+ Hydra: _TermSubst :: Name
+ Hydra: _TermVariableShadowingError :: Name
+ Hydra: _TermVariableShadowingError_location :: Name
+ Hydra: _TermVariableShadowingError_name :: Name
+ Hydra: _TermVariant :: Name
+ Hydra: _TermVariant_annotated :: Name
+ Hydra: _TermVariant_application :: Name
+ Hydra: _TermVariant_cases :: Name
+ Hydra: _TermVariant_either :: Name
+ Hydra: _TermVariant_inject :: Name
+ Hydra: _TermVariant_lambda :: Name
+ Hydra: _TermVariant_let :: Name
+ Hydra: _TermVariant_list :: Name
+ Hydra: _TermVariant_literal :: Name
+ Hydra: _TermVariant_map :: Name
+ Hydra: _TermVariant_optional :: Name
+ Hydra: _TermVariant_pair :: Name
+ Hydra: _TermVariant_project :: Name
+ Hydra: _TermVariant_record :: Name
+ Hydra: _TermVariant_set :: Name
+ Hydra: _TermVariant_typeApplication :: Name
+ Hydra: _TermVariant_typeLambda :: Name
+ Hydra: _TermVariant_unit :: Name
+ Hydra: _TermVariant_unwrap :: Name
+ Hydra: _TermVariant_variable :: Name
+ Hydra: _TermVariant_wrap :: Name
+ Hydra: _Term_annotated :: Name
+ Hydra: _Term_application :: Name
+ Hydra: _Term_cases :: Name
+ Hydra: _Term_either :: Name
+ Hydra: _Term_inject :: Name
+ Hydra: _Term_lambda :: Name
+ Hydra: _Term_let :: Name
+ Hydra: _Term_list :: Name
+ Hydra: _Term_literal :: Name
+ Hydra: _Term_map :: Name
+ Hydra: _Term_optional :: Name
+ Hydra: _Term_pair :: Name
+ Hydra: _Term_project :: Name
+ Hydra: _Term_record :: Name
+ Hydra: _Term_set :: Name
+ Hydra: _Term_typeApplication :: Name
+ Hydra: _Term_typeLambda :: Name
+ Hydra: _Term_unit :: Name
+ Hydra: _Term_unwrap :: Name
+ Hydra: _Term_variable :: Name
+ Hydra: _Term_wrap :: Name
+ Hydra: _TestCase :: Name
+ Hydra: _TestCaseWithMetadata :: Name
+ Hydra: _TestCaseWithMetadata_case :: Name
+ Hydra: _TestCaseWithMetadata_description :: Name
+ Hydra: _TestCaseWithMetadata_name :: Name
+ Hydra: _TestCaseWithMetadata_provisions :: Name
+ Hydra: _TestCaseWithMetadata_tags :: Name
+ Hydra: _TestCase_effectful :: Name
+ Hydra: _TestCase_universal :: Name
+ Hydra: _TestGroup :: Name
+ Hydra: _TestGroup_cases :: Name
+ Hydra: _TestGroup_description :: Name
+ Hydra: _TestGroup_name :: Name
+ Hydra: _TestGroup_subgroups :: Name
+ Hydra: _TraversalOrder :: Name
+ Hydra: _TraversalOrder_post :: Name
+ Hydra: _TraversalOrder_pre :: Name
+ Hydra: _TriplePattern :: Name
+ Hydra: _TriplePattern_object :: Name
+ Hydra: _TriplePattern_predicate :: Name
+ Hydra: _TriplePattern_subject :: Name
+ Hydra: _Type :: Name
+ Hydra: _TypeAdapter :: Name
+ Hydra: _TypeApplicationTerm :: Name
+ Hydra: _TypeApplicationTerm_body :: Name
+ Hydra: _TypeApplicationTerm_type :: Name
+ Hydra: _TypeArityMismatchError :: Name
+ Hydra: _TypeArityMismatchError_actualArity :: Name
+ Hydra: _TypeArityMismatchError_expectedArity :: Name
+ Hydra: _TypeArityMismatchError_type :: Name
+ Hydra: _TypeArityMismatchError_typeArguments :: Name
+ Hydra: _TypeAttributeLink :: Name
+ Hydra: _TypeAttributeLink_annotatedAnnotation :: Name
+ Hydra: _TypeAttributeLink_forallParameter :: Name
+ Hydra: _TypeAttributeLink_literal :: Name
+ Hydra: _TypeClass :: Name
+ Hydra: _TypeClassConstraint :: Name
+ Hydra: _TypeClassConstraint_simple :: Name
+ Hydra: _TypeClass_description :: Name
+ Hydra: _TypeConstraint :: Name
+ Hydra: _TypeConstraint_comment :: Name
+ Hydra: _TypeConstraint_left :: Name
+ Hydra: _TypeConstraint_right :: Name
+ Hydra: _TypeDefinition :: Name
+ Hydra: _TypeDefinition_body :: Name
+ Hydra: _TypeDefinition_metadata :: Name
+ Hydra: _TypeDefinition_name :: Name
+ Hydra: _TypeGraph :: Name
+ Hydra: _TypeGraph_roots :: Name
+ Hydra: _TypeLambda :: Name
+ Hydra: _TypeLambda_body :: Name
+ Hydra: _TypeLambda_parameter :: Name
+ Hydra: _TypeLink :: Name
+ Hydra: _TypeLink_attribute :: Name
+ Hydra: _TypeLink_reference :: Name
+ Hydra: _TypeLink_subtype :: Name
+ Hydra: _TypeMismatchError :: Name
+ Hydra: _TypeMismatchError_actualType :: Name
+ Hydra: _TypeMismatchError_expectedType :: Name
+ Hydra: _TypeNode :: Name
+ Hydra: _TypeNodeId :: Name
+ Hydra: _TypeNodeId_path :: Name
+ Hydra: _TypeNodeId_root :: Name
+ Hydra: _TypeNode_links :: Name
+ Hydra: _TypeNode_type :: Name
+ Hydra: _TypeParameter :: Name
+ Hydra: _TypeParameter_constraints :: Name
+ Hydra: _TypeParameter_name :: Name
+ Hydra: _TypeReference :: Name
+ Hydra: _TypeReferenceLink :: Name
+ Hydra: _TypeReferenceLink_step :: Name
+ Hydra: _TypeReferenceLink_target :: Name
+ Hydra: _TypeReference_nominal :: Name
+ Hydra: _TypeReference_variable :: Name
+ Hydra: _TypeScheme :: Name
+ Hydra: _TypeScheme_body :: Name
+ Hydra: _TypeScheme_constraints :: Name
+ Hydra: _TypeScheme_variables :: Name
+ Hydra: _TypeSubst :: Name
+ Hydra: _TypeVariableConstraints :: Name
+ Hydra: _TypeVariableConstraints_classes :: Name
+ Hydra: _TypeVariableReference :: Name
+ Hydra: _TypeVariableReference_boundByNode :: Name
+ Hydra: _TypeVariableReference_variable :: Name
+ Hydra: _TypeVariableShadowingInForallError :: Name
+ Hydra: _TypeVariableShadowingInForallError_location :: Name
+ Hydra: _TypeVariableShadowingInForallError_name :: Name
+ Hydra: _TypeVariableShadowingInTypeLambdaError :: Name
+ Hydra: _TypeVariableShadowingInTypeLambdaError_location :: Name
+ Hydra: _TypeVariableShadowingInTypeLambdaError_name :: Name
+ Hydra: _TypeVariant :: Name
+ Hydra: _TypeVariant_annotated :: Name
+ Hydra: _TypeVariant_application :: Name
+ Hydra: _TypeVariant_effect :: Name
+ Hydra: _TypeVariant_either :: Name
+ Hydra: _TypeVariant_forall :: Name
+ Hydra: _TypeVariant_function :: Name
+ Hydra: _TypeVariant_list :: Name
+ Hydra: _TypeVariant_literal :: Name
+ Hydra: _TypeVariant_map :: Name
+ Hydra: _TypeVariant_optional :: Name
+ Hydra: _TypeVariant_pair :: Name
+ Hydra: _TypeVariant_record :: Name
+ Hydra: _TypeVariant_set :: Name
+ Hydra: _TypeVariant_union :: Name
+ Hydra: _TypeVariant_unit :: Name
+ Hydra: _TypeVariant_variable :: Name
+ Hydra: _TypeVariant_void :: Name
+ Hydra: _TypeVariant_wrap :: Name
+ Hydra: _Type_annotated :: Name
+ Hydra: _Type_application :: Name
+ Hydra: _Type_effect :: Name
+ Hydra: _Type_either :: Name
+ Hydra: _Type_forall :: Name
+ Hydra: _Type_function :: Name
+ Hydra: _Type_list :: Name
+ Hydra: _Type_literal :: Name
+ Hydra: _Type_map :: Name
+ Hydra: _Type_optional :: Name
+ Hydra: _Type_pair :: Name
+ Hydra: _Type_record :: Name
+ Hydra: _Type_set :: Name
+ Hydra: _Type_union :: Name
+ Hydra: _Type_unit :: Name
+ Hydra: _Type_variable :: Name
+ Hydra: _Type_void :: Name
+ Hydra: _Type_wrap :: Name
+ Hydra: _TypedBinding :: Name
+ Hydra: _TypedBinding_name :: Name
+ Hydra: _TypedBinding_term :: Name
+ Hydra: _TypedName :: Name
+ Hydra: _TypedTerm :: Name
+ Hydra: _TypedTermDefinition :: Name
+ Hydra: _TypedTermDefinition_name :: Name
+ Hydra: _TypedTermDefinition_term :: Name
+ Hydra: _UnboundTypeVariablesError :: Name
+ Hydra: _UnboundTypeVariablesError_type :: Name
+ Hydra: _UnboundTypeVariablesError_variables :: Name
+ Hydra: _UndeclaredVariantError :: Name
+ Hydra: _UndeclaredVariantError_location :: Name
+ Hydra: _UndeclaredVariantError_typeName :: Name
+ Hydra: _UndeclaredVariantError_variantName :: Name
+ Hydra: _UndefinedFieldError :: Name
+ Hydra: _UndefinedFieldError_fieldName :: Name
+ Hydra: _UndefinedFieldError_typeName :: Name
+ Hydra: _UndefinedTermVariableCheckingError :: Name
+ Hydra: _UndefinedTermVariableCheckingError_name :: Name
+ Hydra: _UndefinedTermVariableCheckingError_path :: Name
+ Hydra: _UndefinedTermVariableError :: Name
+ Hydra: _UndefinedTermVariableError_location :: Name
+ Hydra: _UndefinedTermVariableError_name :: Name
+ Hydra: _UndefinedTypeVariableError :: Name
+ Hydra: _UndefinedTypeVariableError_location :: Name
+ Hydra: _UndefinedTypeVariableError_name :: Name
+ Hydra: _UndefinedTypeVariableInBindingTypeError :: Name
+ Hydra: _UndefinedTypeVariableInBindingTypeError_location :: Name
+ Hydra: _UndefinedTypeVariableInBindingTypeError_name :: Name
+ Hydra: _UndefinedTypeVariableInLambdaDomainError :: Name
+ Hydra: _UndefinedTypeVariableInLambdaDomainError_location :: Name
+ Hydra: _UndefinedTypeVariableInLambdaDomainError_name :: Name
+ Hydra: _UndefinedTypeVariableInTypeApplicationError :: Name
+ Hydra: _UndefinedTypeVariableInTypeApplicationError_location :: Name
+ Hydra: _UndefinedTypeVariableInTypeApplicationError_name :: Name
+ Hydra: _UnequalTypesError :: Name
+ Hydra: _UnequalTypesError_description :: Name
+ Hydra: _UnequalTypesError_types :: Name
+ Hydra: _UnexpectedShapeError :: Name
+ Hydra: _UnexpectedShapeError_actual :: Name
+ Hydra: _UnexpectedShapeError_expected :: Name
+ Hydra: _UnexpectedTermVariantError :: Name
+ Hydra: _UnexpectedTermVariantError_actualTerm :: Name
+ Hydra: _UnexpectedTermVariantError_expectedVariant :: Name
+ Hydra: _UnexpectedTypeVariantError :: Name
+ Hydra: _UnexpectedTypeVariantError_actualType :: Name
+ Hydra: _UnexpectedTypeVariantError_expectedVariant :: Name
+ Hydra: _UnificationError :: Name
+ Hydra: _UnificationError_leftType :: Name
+ Hydra: _UnificationError_message :: Name
+ Hydra: _UnificationError_rightType :: Name
+ Hydra: _UnificationInferenceError :: Name
+ Hydra: _UnificationInferenceError_cause :: Name
+ Hydra: _UnificationInferenceError_path :: Name
+ Hydra: _UniversalTestCase :: Name
+ Hydra: _UniversalTestCase_actual :: Name
+ Hydra: _UniversalTestCase_expected :: Name
+ Hydra: _UnknownCaseAlternativeError :: Name
+ Hydra: _UnknownCaseAlternativeError_location :: Name
+ Hydra: _UnknownCaseAlternativeError_name :: Name
+ Hydra: _UnknownCaseAlternativeError_typeName :: Name
+ Hydra: _UnknownPrimitiveNameError :: Name
+ Hydra: _UnknownPrimitiveNameError_location :: Name
+ Hydra: _UnknownPrimitiveNameError_name :: Name
+ Hydra: _UnknownProjectedFieldError :: Name
+ Hydra: _UnknownProjectedFieldError_fieldName :: Name
+ Hydra: _UnknownProjectedFieldError_location :: Name
+ Hydra: _UnknownProjectedFieldError_typeName :: Name
+ Hydra: _UnnecessaryIdentityApplicationError :: Name
+ Hydra: _UnnecessaryIdentityApplicationError_location :: Name
+ Hydra: _UnresolvedNominalTypeError :: Name
+ Hydra: _UnresolvedNominalTypeError_location :: Name
+ Hydra: _UnresolvedNominalTypeError_typeName :: Name
+ Hydra: _UnsupportedTermVariantError :: Name
+ Hydra: _UnsupportedTermVariantError_termVariant :: Name
+ Hydra: _UntypedLambdaError :: Name
+ Hydra: _UntypedLetBindingError :: Name
+ Hydra: _UntypedLetBindingError_binding :: Name
+ Hydra: _UntypedTermVariableCheckingError :: Name
+ Hydra: _UntypedTermVariableCheckingError_name :: Name
+ Hydra: _UntypedTermVariableCheckingError_path :: Name
+ Hydra: _UntypedTermVariableError :: Name
+ Hydra: _UntypedTermVariableError_location :: Name
+ Hydra: _UntypedTermVariableError_name :: Name
+ Hydra: _ValidationProfile :: Name
+ Hydra: _ValidationProfile_errorRules :: Name
+ Hydra: _ValidationProfile_maxErrors :: Name
+ Hydra: _ValidationProfile_maxWarnings :: Name
+ Hydra: _ValidationProfile_warningRules :: Name
+ Hydra: _ValidationResult :: Name
+ Hydra: _ValidationResult_errors :: Name
+ Hydra: _ValidationResult_warnings :: Name
+ Hydra: _Variable :: Name
+ Hydra: _Version :: Name
+ Hydra: _VersionRange :: Name
+ Hydra: _VersionRange_lowerInclusive :: Name
+ Hydra: _VersionRange_upperExclusive :: Name
+ Hydra: _VersionSpecifier :: Name
+ Hydra: _VersionSpecifier_any :: Name
+ Hydra: _VersionSpecifier_atLeast :: Name
+ Hydra: _VersionSpecifier_exact :: Name
+ Hydra: _VersionSpecifier_range :: Name
+ Hydra: _VoidInNonBottomPositionError :: Name
+ Hydra: _VoidInNonBottomPositionError_location :: Name
+ Hydra: _WrappedTerm :: Name
+ Hydra: _WrappedTerm_body :: Name
+ Hydra: _WrappedTerm_typeName :: Name
+ Hydra: adaptDataGraph :: LanguageConstraints -> Bool -> [Binding] -> t0 -> Graph -> Either Error (Graph, [Binding])
+ Hydra: adaptFloatType :: LanguageConstraints -> FloatType -> Maybe FloatType
+ Hydra: adaptGraphSchema :: Ord t0 => LanguageConstraints -> Map LiteralType LiteralType -> Map t0 Type -> Either Error (Map t0 Type)
+ Hydra: adaptIntegerType :: LanguageConstraints -> IntegerType -> Maybe IntegerType
+ Hydra: adaptLambdaDomains :: LanguageConstraints -> Map LiteralType LiteralType -> (t0 -> Either Error Term) -> t0 -> Either Error Term
+ Hydra: adaptLiteral :: LiteralType -> Literal -> Literal
+ Hydra: adaptLiteralType :: LanguageConstraints -> LiteralType -> Maybe LiteralType
+ Hydra: adaptLiteralTypesMap :: LanguageConstraints -> Map LiteralType LiteralType
+ Hydra: adaptLiteralValue :: Ord t0 => Map t0 LiteralType -> t0 -> Literal -> Literal
+ Hydra: adaptNestedTypes :: LanguageConstraints -> Map LiteralType LiteralType -> (t0 -> Either Error Term) -> t0 -> Either Error Term
+ Hydra: adaptPrimitive :: LanguageConstraints -> Map LiteralType LiteralType -> Primitive -> Either Error Primitive
+ Hydra: adaptTerm :: LanguageConstraints -> Map LiteralType LiteralType -> t0 -> Graph -> Term -> Either Error Term
+ Hydra: adaptTermForLanguage :: Language -> t0 -> Graph -> Term -> Either Error Term
+ Hydra: adaptTermSignature :: LanguageConstraints -> Map LiteralType LiteralType -> TermSignature -> Either Error TermSignature
+ Hydra: adaptType :: LanguageConstraints -> Map LiteralType LiteralType -> Type -> Either Error Type
+ Hydra: adaptTypeForLanguage :: Language -> Type -> Either Error Type
+ Hydra: adaptTypeScheme :: LanguageConstraints -> Map LiteralType LiteralType -> TypeScheme -> Either Error TypeScheme
+ Hydra: addNamesToModuleNames :: (ModuleName -> t0) -> Set Name -> ModuleNames t0 -> ModuleNames t0
+ Hydra: adjacencyListToMap :: Ord t0 => [(t0, [t1])] -> Map t0 [t1]
+ Hydra: adjacencyListsToGraph :: Ord t0 => [(t0, [t0])] -> (Map Int [Int], Int -> Maybe t0)
+ Hydra: aggregateAnnotations :: Ord t2 => (t0 -> Maybe t1) -> (t1 -> t0) -> (t1 -> Map t2 t3) -> t0 -> Map t2 t3
+ Hydra: allEqual :: Eq t0 => [t0] -> Bool
+ Hydra: alphaConvert :: Name -> Name -> Term -> Term
+ Hydra: analyzeFunctionTerm :: InferenceContext -> (t0 -> Graph) -> (Graph -> t0 -> t0) -> t0 -> Term -> Either t1 (FunctionStructure t0)
+ Hydra: analyzeFunctionTermWith :: InferenceContext -> (Graph -> Binding -> Maybe Term) -> (t0 -> Graph) -> (Graph -> t0 -> t0) -> t0 -> Term -> Either t1 (FunctionStructure t0)
+ Hydra: analyzeFunctionTermWithFinish :: InferenceContext -> (t0 -> Graph) -> t0 -> [Name] -> [Name] -> [Binding] -> [Type] -> [Type] -> Term -> Either t1 (FunctionStructure t0)
+ Hydra: analyzeFunctionTermWithGather :: InferenceContext -> (Graph -> Binding -> Maybe Term) -> (t0 -> Graph) -> (Graph -> t0 -> t0) -> Bool -> t0 -> [Name] -> [Name] -> [Binding] -> [Type] -> [Type] -> Term -> Either t1 (FunctionStructure t0)
+ Hydra: angleBraces :: Brackets
+ Hydra: angleBracesList :: BlockStyle -> [Expr] -> Expr
+ Hydra: applyInsideTypeLambdasAndAnnotations :: (Term -> Term) -> Term -> Term
+ Hydra: applyTypeArgumentsToType :: InferenceContext -> Graph -> [Type] -> Type -> Either Error Type
+ Hydra: atOrFail :: Int -> String -> [t0] -> Either Error t0
+ Hydra: betaReduceType :: t0 -> Graph -> Type -> Either Error Type
+ Hydra: bigintToIntegerValue :: IntegerType -> Integer -> IntegerValue
+ Hydra: bindConstraints :: InferenceContext -> Graph -> [TypeConstraint] -> Either Error TypeSubst
+ Hydra: bindUnboundTypeVariables :: Graph -> Term -> Term
+ Hydra: bracesListAdaptive :: [Expr] -> Expr
+ Hydra: bracketList :: BlockStyle -> [Expr] -> Expr
+ Hydra: bracketListAdaptive :: [Expr] -> Expr
+ Hydra: brackets :: Brackets -> BlockStyle -> Expr -> Expr
+ Hydra: buildGraph :: [Binding] -> Map Name (Maybe Term) -> Map Name Primitive -> Graph
+ Hydra: buildTypeApplicationTerm :: [Name] -> Term -> Term
+ Hydra: capitalize :: String -> String
+ Hydra: checkForUnboundTypeVariables :: t0 -> Graph -> Term -> Either Error ()
+ Hydra: checkSameType :: t0 -> Graph -> String -> [Type] -> Either Error Type
+ Hydra: checkTypeSubst :: t0 -> Graph -> TypeSubst -> Either Error TypeSubst
+ Hydra: chooseLayout :: Int -> Expr -> Expr -> Expr
+ Hydra: chooseUniqueLabel :: Set String -> String -> String
+ Hydra: chooseUniqueName :: Set Name -> Name -> Name
+ Hydra: commaSep :: BlockStyle -> [Expr] -> Expr
+ Hydra: commaSepAdaptive :: [Expr] -> Expr
+ Hydra: commentsFromBinding :: t0 -> Graph -> Binding -> Either Error (Maybe String)
+ Hydra: commentsFromFieldType :: t0 -> Graph -> FieldType -> Either Error (Maybe String)
+ Hydra: compactName :: Map ModuleName String -> Name -> String
+ Hydra: composeCoders :: Coder t0 t1 t2 -> Coder t1 t3 t2 -> Coder t0 t3 t2
+ Hydra: composeProvisionName :: Name -> String -> Name
+ Hydra: composeTypeSubst :: TypeSubst -> TypeSubst -> TypeSubst
+ Hydra: composeTypeSubstList :: [TypeSubst] -> TypeSubst
+ Hydra: composeTypeSubstNonEmpty :: TypeSubst -> TypeSubst -> TypeSubst
+ Hydra: containsInScopeTypeVars :: Graph -> Type -> Bool
+ Hydra: contractTerm :: Term -> Term
+ Hydra: convertCase :: CaseConvention -> CaseConvention -> String -> String
+ Hydra: convertCaseCamelOrUnderscoreToLowerSnake :: String -> String
+ Hydra: convertCaseCamelToLowerSnake :: String -> String
+ Hydra: convertCaseCamelToUpperSnake :: String -> String
+ Hydra: convertCasePascalToUpperSnake :: String -> String
+ Hydra: countPrimitiveInvocations :: Bool
+ Hydra: createOrderingIsomorphism :: Ord t0 => [t0] -> [t0] -> OrderingIsomorphism t1
+ Hydra: cst :: String -> Expr
+ Hydra: curlyBlock :: BlockStyle -> Expr -> Expr
+ Hydra: curlyBraces :: Brackets
+ Hydra: curlyBracesList :: Maybe String -> BlockStyle -> [Expr] -> Expr
+ Hydra: customIndent :: String -> String -> String
+ Hydra: customIndentBlock :: String -> [Expr] -> Expr
+ Hydra: data Adapter t1 t2 v1 v2 e
+ Hydra: data AdapterContext
+ Hydra: data AnnotatedTerm
+ Hydra: data AnnotatedType
+ Hydra: data Application
+ Hydra: data ApplicationType
+ Hydra: data Bicoder t1 t2 v1 v2 e
+ Hydra: data Binding
+ Hydra: data CaseAlternative
+ Hydra: data CaseConvention
+ Hydra: data CaseConventions
+ Hydra: data CaseStatement
+ Hydra: data CheckingError
+ Hydra: data Coder v1 v2 e
+ Hydra: data CoderDirection
+ Hydra: data ColumnSchema t
+ Hydra: data ColumnType
+ Hydra: data Comparison
+ Hydra: data ComparisonConstraint
+ Hydra: data ConstantConditionError
+ Hydra: data Definition
+ Hydra: data DefinitionReference
+ Hydra: data DependencyScope
+ Hydra: data DuplicateBindingError
+ Hydra: data DuplicateFieldError
+ Hydra: data DuplicateRecordTypeFieldNamesError
+ Hydra: data DuplicateUnionTypeFieldNamesError
+ Hydra: data Edge
+ Hydra: data EffectfulTestCase
+ Hydra: data EitherType
+ Hydra: data EmptyCaseStatementError
+ Hydra: data EmptyLetBindingsError
+ Hydra: data EmptyRecordTypeError
+ Hydra: data EmptyTermAnnotationError
+ Hydra: data EmptyTypeAnnotationError
+ Hydra: data EmptyTypeNameInTermError
+ Hydra: data EmptyUnionTypeError
+ Hydra: data EntityMetadata
+ Hydra: data EntityReference
+ Hydra: data Error
+ Hydra: data ExtraRecordFieldsError
+ Hydra: data ExtractionError
+ Hydra: data Field
+ Hydra: data FieldType
+ Hydra: data FloatType
+ Hydra: data FloatValue
+ Hydra: data ForallType
+ Hydra: data ForeignKey
+ Hydra: data FunctionStructure env
+ Hydra: data FunctionType
+ Hydra: data Graph
+ Hydra: data GraphPattern
+ Hydra: data IncorrectUnificationError
+ Hydra: data InferenceContext
+ Hydra: data InferenceError
+ Hydra: data InferenceResult
+ Hydra: data Injection
+ Hydra: data IntegerType
+ Hydra: data IntegerValue
+ Hydra: data InvalidForallParameterNameError
+ Hydra: data InvalidLambdaParameterNameError
+ Hydra: data InvalidLetBindingNameError
+ Hydra: data InvalidLiteralError
+ Hydra: data InvalidTermError
+ Hydra: data InvalidTypeError
+ Hydra: data InvalidTypeLambdaParameterNameError
+ Hydra: data InvalidTypeSchemeVariableNameError
+ Hydra: data Lambda
+ Hydra: data LambdaVariableReference
+ Hydra: data Language
+ Hydra: data LanguageConstraints
+ Hydra: data LanguageFeature
+ Hydra: data Let
+ Hydra: data LetVariableReference
+ Hydra: data Library
+ Hydra: data LifecycleInfo
+ Hydra: data Literal
+ Hydra: data LiteralType
+ Hydra: data LiteralTypeMismatchError
+ Hydra: data LiteralVariant
+ Hydra: data MapType
+ Hydra: data MissingCaseBranchesError
+ Hydra: data MissingRecordFieldsError
+ Hydra: data Module
+ Hydra: data ModuleDependency
+ Hydra: data ModuleNames n
+ Hydra: data MultipleBindingsError
+ Hydra: data MultipleFieldsError
+ Hydra: data NestedTermAnnotationError
+ Hydra: data NestedTypeAnnotationError
+ Hydra: data NoMatchingFieldError
+ Hydra: data NoSuchBindingError
+ Hydra: data NoSuchPrimitiveError
+ Hydra: data Node
+ Hydra: data NominalTypeKindMismatchError
+ Hydra: data NominalTypeReference
+ Hydra: data NonComparableMapKeyTypeError
+ Hydra: data NonComparableSetElementTypeError
+ Hydra: data NotAForallTypeError
+ Hydra: data NotAFunctionTypeError
+ Hydra: data OtherCheckingError
+ Hydra: data OtherInferenceError
+ Hydra: data Package
+ Hydra: data PackageDependency
+ Hydra: data PairType
+ Hydra: data Parameter
+ Hydra: data ParseError
+ Hydra: data ParseResult a
+ Hydra: data ParseSuccess a
+ Hydra: data Path
+ Hydra: data PathEquation
+ Hydra: data Pattern
+ Hydra: data PatternImplication
+ Hydra: data Precision
+ Hydra: data Primitive
+ Hydra: data PrimitiveDefinition
+ Hydra: data PrimitiveReference
+ Hydra: data Projection
+ Hydra: data Provision
+ Hydra: data ProvisionKind
+ Hydra: data QualifiedName
+ Hydra: data Query
+ Hydra: data Range
+ Hydra: data Record
+ Hydra: data RedundantWrapUnwrapError
+ Hydra: data RegexQuantifier
+ Hydra: data RegexSequence
+ Hydra: data RelationSchema t
+ Hydra: data ResolutionError
+ Hydra: data Result
+ Hydra: data SelfApplicationError
+ Hydra: data SingleVariantUnionError
+ Hydra: data Step
+ Hydra: data SubtermLink
+ Hydra: data SubtermStep
+ Hydra: data SubtypeLink
+ Hydra: data SubtypeStep
+ Hydra: data Table v
+ Hydra: data TableType
+ Hydra: data Term
+ Hydra: data TermAttributeLink
+ Hydra: data TermCoder a
+ Hydra: data TermDefinition
+ Hydra: data TermGraph
+ Hydra: data TermLink
+ Hydra: data TermNode
+ Hydra: data TermNodeId
+ Hydra: data TermReference
+ Hydra: data TermReferenceLink
+ Hydra: data TermSignature
+ Hydra: data TermVariableShadowingError
+ Hydra: data TermVariant
+ Hydra: data TestCase
+ Hydra: data TestCaseWithMetadata
+ Hydra: data TestGroup
+ Hydra: data TraversalOrder
+ Hydra: data TriplePattern
+ Hydra: data Type
+ Hydra: data TypeApplicationTerm
+ Hydra: data TypeArityMismatchError
+ Hydra: data TypeAttributeLink
+ Hydra: data TypeClass
+ Hydra: data TypeClassConstraint
+ Hydra: data TypeConstraint
+ Hydra: data TypeDefinition
+ Hydra: data TypeGraph
+ Hydra: data TypeLambda
+ Hydra: data TypeLink
+ Hydra: data TypeMismatchError
+ Hydra: data TypeNode
+ Hydra: data TypeNodeId
+ Hydra: data TypeParameter
+ Hydra: data TypeReference
+ Hydra: data TypeReferenceLink
+ Hydra: data TypeScheme
+ Hydra: data TypeVariableConstraints
+ Hydra: data TypeVariableReference
+ Hydra: data TypeVariableShadowingInForallError
+ Hydra: data TypeVariableShadowingInTypeLambdaError
+ Hydra: data TypeVariant
+ Hydra: data TypedBinding a
+ Hydra: data TypedTermDefinition a
+ Hydra: data UnboundTypeVariablesError
+ Hydra: data UndeclaredVariantError
+ Hydra: data UndefinedFieldError
+ Hydra: data UndefinedTermVariableCheckingError
+ Hydra: data UndefinedTermVariableError
+ Hydra: data UndefinedTypeVariableError
+ Hydra: data UndefinedTypeVariableInBindingTypeError
+ Hydra: data UndefinedTypeVariableInLambdaDomainError
+ Hydra: data UndefinedTypeVariableInTypeApplicationError
+ Hydra: data UnequalTypesError
+ Hydra: data UnexpectedShapeError
+ Hydra: data UnexpectedTermVariantError
+ Hydra: data UnexpectedTypeVariantError
+ Hydra: data UnificationError
+ Hydra: data UnificationInferenceError
+ Hydra: data UniversalTestCase
+ Hydra: data UnknownCaseAlternativeError
+ Hydra: data UnknownPrimitiveNameError
+ Hydra: data UnknownProjectedFieldError
+ Hydra: data UnnecessaryIdentityApplicationError
+ Hydra: data UnresolvedNominalTypeError
+ Hydra: data UnsupportedTermVariantError
+ Hydra: data UntypedLambdaError
+ Hydra: data UntypedLetBindingError
+ Hydra: data UntypedTermVariableCheckingError
+ Hydra: data UntypedTermVariableError
+ Hydra: data ValidationProfile
+ Hydra: data ValidationResult e
+ Hydra: data VersionRange
+ Hydra: data VersionSpecifier
+ Hydra: data VoidInNonBottomPositionError
+ Hydra: data WrappedTerm
+ Hydra: dataGraphToDefinitions :: LanguageConstraints -> Bool -> Bool -> Bool -> Bool -> [Binding] -> Graph -> [ModuleName] -> InferenceContext -> Either Error (Graph, [[TermDefinition]])
+ Hydra: deannotateAndDetypeTerm :: Term -> Term
+ Hydra: deannotateTerm :: Term -> Term
+ Hydra: deannotateType :: Type -> Type
+ Hydra: deannotateTypeParameters :: Type -> Type
+ Hydra: deannotateTypeRecursive :: Type -> Type
+ Hydra: deannotateTypeSchemeRecursive :: TypeScheme -> TypeScheme
+ Hydra: decapitalize :: String -> String
+ Hydra: definitionAsTypeApplicationTerm :: Binding -> Either Error TypeApplicationTerm
+ Hydra: definitionDependencyModuleNames :: [Definition] -> Set ModuleName
+ Hydra: definitionsWithDependencies :: t0 -> Graph -> [Binding] -> Either Error [Binding]
+ Hydra: dependencyModuleNames :: t0 -> Graph -> Bool -> Bool -> Bool -> Bool -> [Binding] -> Either Error (Set ModuleName)
+ Hydra: dereferenceSchemaType :: Name -> Map Name TypeScheme -> Maybe TypeScheme
+ Hydra: dereferenceType :: t0 -> Graph -> Name -> Either Error (Maybe Type)
+ Hydra: dereferenceVariable :: Graph -> Name -> Either Error Binding
+ Hydra: derivedBindingName :: [String] -> t0 -> Name -> Name
+ Hydra: derivedDefinitionName :: [String] -> t0 -> Bool -> Name -> String -> Name
+ Hydra: derivedModuleName :: [String] -> t0 -> ModuleName -> ModuleName
+ Hydra: detypeTerm :: Term -> Term
+ Hydra: dischargeClassConstraints :: InferenceContext -> TypeSubst -> Map Name TypeVariableConstraints -> Either Error ()
+ Hydra: dotSep :: [Expr] -> Expr
+ Hydra: doubleNewlineSep :: [Expr] -> Expr
+ Hydra: doubleSpace :: String
+ Hydra: elementsToGraph :: Graph -> Map Name TypeScheme -> [Binding] -> Graph
+ Hydra: emptyGraph :: Graph
+ Hydra: emptyInferenceContext :: InferenceContext
+ Hydra: escapeWithUnderscore :: Set String -> String -> String
+ Hydra: etaExpandTerm :: Graph -> Term -> Term
+ Hydra: etaExpandTypedTerm :: InferenceContext -> Graph -> Term -> Either Error Term
+ Hydra: etaExpansionArity :: Graph -> Term -> Int
+ Hydra: etaReduceTerm :: Term -> Term
+ Hydra: expressionLength :: Expr -> Int
+ Hydra: extendContext :: [(Name, TypeScheme)] -> Graph -> Graph
+ Hydra: extendGraphForLambda :: Graph -> Lambda -> Graph
+ Hydra: extendGraphForLet :: (Graph -> Binding -> Maybe Term) -> Graph -> Let -> Graph
+ Hydra: extendGraphForTypeLambda :: Graph -> TypeLambda -> Graph
+ Hydra: extendGraphWithBindings :: [Binding] -> Graph -> Graph
+ Hydra: fTypeIsPolymorphic :: Type -> Bool
+ Hydra: fTypeToTypeScheme :: Type -> TypeScheme
+ Hydra: fieldMap :: [Field] -> Map Name Term
+ Hydra: fieldNameValue :: String
+ Hydra: fieldTypeMap :: [FieldType] -> Map Name Type
+ Hydra: fieldTypes :: t0 -> Graph -> Type -> Either Error (Map Name Type)
+ Hydra: fieldsOf :: Type -> [FieldType]
+ Hydra: finalizeInferredTerm :: t0 -> Graph -> Term -> Either Error Term
+ Hydra: findFieldType :: t0 -> Name -> [FieldType] -> Either Error Type
+ Hydra: findReachableNodes :: Ord t0 => (t0 -> Set t0) -> t0 -> Set t0
+ Hydra: flattenLetTerms :: Term -> Term
+ Hydra: floatTypePrecision :: FloatType -> Precision
+ Hydra: floatTypes :: [FloatType]
+ Hydra: floatValueType :: FloatValue -> FloatType
+ Hydra: foldOverTerm :: TraversalOrder -> (t0 -> Term -> t0) -> t0 -> Term -> t0
+ Hydra: foldOverType :: TraversalOrder -> (t0 -> Type -> t0) -> t0 -> Type -> t0
+ Hydra: foldTermWithGraphAndPath :: ((t0 -> Term -> t0) -> [SubtermStep] -> Graph -> t0 -> Term -> t0) -> Graph -> t0 -> Term -> t0
+ Hydra: forInferredTerm :: InferenceContext -> Graph -> Term -> String -> (InferenceResult -> t0) -> Either Error (t0, InferenceContext)
+ Hydra: freeTypeVariablesInTerm :: Term -> Set Name
+ Hydra: freeVariablesInContext :: Graph -> Set Name
+ Hydra: freeVariablesInTerm :: Term -> Set Name
+ Hydra: freeVariablesInType :: Type -> Set Name
+ Hydra: freeVariablesInTypeOrdered :: Type -> [Name]
+ Hydra: freeVariablesInTypeScheme :: TypeScheme -> Set Name
+ Hydra: freeVariablesInTypeSchemeSimple :: TypeScheme -> Set Name
+ Hydra: freeVariablesInTypeSimple :: Type -> Set Name
+ Hydra: freshName :: InferenceContext -> (Name, InferenceContext)
+ Hydra: freshNames :: Int -> InferenceContext -> ([Name], InferenceContext)
+ Hydra: freshVariableType :: InferenceContext -> (Type, InferenceContext)
+ Hydra: fullBlockStyle :: BlockStyle
+ Hydra: fullyStripAndNormalizeType :: Type -> Type
+ Hydra: fullyStripType :: Type -> Type
+ Hydra: gatherApplications :: Term -> ([Term], Term)
+ Hydra: gatherArgs :: Term -> [Term] -> (Term, [Term])
+ Hydra: gatherArgsWithTypeApps :: Term -> [Term] -> [Type] -> (Term, ([Term], [Type]))
+ Hydra: generalize :: Graph -> Type -> TypeScheme
+ Hydra: getAnnotationMap :: Term -> Map Name Term
+ Hydra: getDescription :: t0 -> Graph -> Map Name Term -> Either Error (Maybe String)
+ Hydra: getField :: Map Name t0 -> Name -> (t0 -> Either Error t1) -> Either Error t1
+ Hydra: getTermAnnotation :: Name -> Term -> Maybe Term
+ Hydra: getTermDescription :: t0 -> Graph -> Term -> Either Error (Maybe String)
+ Hydra: getType :: Graph -> Map Name Term -> Either DecodingError (Maybe Type)
+ Hydra: getTypeAnnotation :: Name -> Type -> Maybe Term
+ Hydra: getTypeClasses :: t0 -> Graph -> Term -> Either Error (Map Name (Set Name))
+ Hydra: getTypeDescription :: t0 -> Graph -> Type -> Either Error (Maybe String)
+ Hydra: graphAsLet :: [Binding] -> Term -> Let
+ Hydra: graphAsTerm :: [Binding] -> Term -> Term
+ Hydra: graphAsTypes :: Graph -> [Binding] -> Either DecodingError (Map Name Type)
+ Hydra: graphToBindings :: Graph -> [Binding]
+ Hydra: graphToSchema :: t0 -> Graph -> [Binding] -> Either DecodingError (Map Name Type)
+ Hydra: graphWithPrimitives :: [Primitive] -> [Primitive] -> Graph
+ Hydra: halfBlockStyle :: BlockStyle
+ Hydra: hasDescription :: Map Name t0 -> Bool
+ Hydra: hasTypeDescription :: Type -> Bool
+ Hydra: headOrFail :: String -> [t0] -> Either Error t0
+ Hydra: hydraDebug :: Bool
+ Hydra: hydraLanguage :: Language
+ Hydra: idTypeSubst :: TypeSubst
+ Hydra: ifx :: Op -> Expr -> Expr -> Expr
+ Hydra: ignoredVariable :: String
+ Hydra: indent :: String -> String
+ Hydra: indentBlock :: [Expr] -> Expr
+ Hydra: indentLines :: String -> String
+ Hydra: indentSubsequentLines :: String -> Expr -> Expr
+ Hydra: inferGraphTypes :: InferenceContext -> [Binding] -> Graph -> Either Error ((Graph, [Binding]), InferenceContext)
+ Hydra: inferInGraphContext :: InferenceContext -> Graph -> Term -> Either Error InferenceResult
+ Hydra: inferMany :: InferenceContext -> Graph -> [(Term, String)] -> Either Error (([Term], ([Type], (TypeSubst, Map Name TypeVariableConstraints))), InferenceContext)
+ Hydra: inferTypeOf :: InferenceContext -> Graph -> Term -> Either Error ((Term, TypeScheme), InferenceContext)
+ Hydra: inferTypeOfAnnotatedTerm :: InferenceContext -> Graph -> AnnotatedTerm -> Either Error InferenceResult
+ Hydra: inferTypeOfApplication :: InferenceContext -> Graph -> Application -> Either Error InferenceResult
+ Hydra: inferTypeOfCaseStatement :: InferenceContext -> Graph -> CaseStatement -> Either Error InferenceResult
+ Hydra: inferTypeOfCollection :: InferenceContext -> Graph -> (Type -> Type) -> ([Term] -> Term) -> String -> Set Name -> [Term] -> Either Error InferenceResult
+ Hydra: inferTypeOfEither :: InferenceContext -> Graph -> Either Term Term -> Either Error InferenceResult
+ Hydra: inferTypeOfInjection :: InferenceContext -> Graph -> Injection -> Either Error InferenceResult
+ Hydra: inferTypeOfLambda :: InferenceContext -> Graph -> Lambda -> Either Error InferenceResult
+ Hydra: inferTypeOfLet :: InferenceContext -> Graph -> Let -> Either Error InferenceResult
+ Hydra: inferTypeOfLetNormalized :: InferenceContext -> Graph -> Let -> Either Error InferenceResult
+ Hydra: inferTypeOfList :: InferenceContext -> Graph -> [Term] -> Either Error InferenceResult
+ Hydra: inferTypeOfLiteral :: InferenceContext -> Literal -> InferenceResult
+ Hydra: inferTypeOfMap :: InferenceContext -> Graph -> Map Term Term -> Either Error InferenceResult
+ Hydra: inferTypeOfOptional :: InferenceContext -> Graph -> Maybe Term -> Either Error InferenceResult
+ Hydra: inferTypeOfPair :: InferenceContext -> Graph -> (Term, Term) -> Either Error InferenceResult
+ Hydra: inferTypeOfProjection :: InferenceContext -> Graph -> Projection -> Either Error InferenceResult
+ Hydra: inferTypeOfRecord :: InferenceContext -> Graph -> Record -> Either Error InferenceResult
+ Hydra: inferTypeOfSet :: InferenceContext -> Graph -> Set Term -> Either Error InferenceResult
+ Hydra: inferTypeOfTerm :: InferenceContext -> Graph -> Term -> String -> Either Error InferenceResult
+ Hydra: inferTypeOfTypeApplication :: InferenceContext -> Graph -> TypeApplicationTerm -> Either Error InferenceResult
+ Hydra: inferTypeOfTypeLambda :: InferenceContext -> Graph -> TypeLambda -> Either Error InferenceResult
+ Hydra: inferTypeOfUnit :: InferenceContext -> InferenceResult
+ Hydra: inferTypeOfUnwrap :: InferenceContext -> Graph -> Name -> Either Error InferenceResult
+ Hydra: inferTypeOfVariable :: InferenceContext -> Graph -> Name -> Either Error InferenceResult
+ Hydra: inferTypeOfWrappedTerm :: InferenceContext -> Graph -> WrappedTerm -> Either Error InferenceResult
+ Hydra: inferTypesOfTemporaryBindings :: InferenceContext -> Graph -> [Binding] -> Either Error (([Term], ([Type], (TypeSubst, Map Name TypeVariableConstraints))), InferenceContext)
+ Hydra: infixWs :: String -> Expr -> Expr -> Expr
+ Hydra: infixWsList :: String -> [Expr] -> Expr
+ Hydra: initialState :: TarjanState
+ Hydra: inlineStyle :: BlockStyle
+ Hydra: inlineType :: Map Name Type -> Type -> Either Error Type
+ Hydra: instantiateTemplate :: t0 -> Bool -> Map Name Type -> Name -> Type -> Either Error Term
+ Hydra: instantiateType :: InferenceContext -> Type -> (Type, InferenceContext)
+ Hydra: instantiateTypeScheme :: InferenceContext -> TypeScheme -> (TypeScheme, InferenceContext)
+ Hydra: integerTypeIsSigned :: IntegerType -> Bool
+ Hydra: integerTypePrecision :: IntegerType -> Precision
+ Hydra: integerTypes :: [IntegerType]
+ Hydra: integerValueToBigint :: IntegerValue -> Integer
+ Hydra: integerValueType :: IntegerValue -> IntegerType
+ Hydra: isComplexBinding :: Graph -> Binding -> Bool
+ Hydra: isComplexTerm :: Graph -> Term -> Bool
+ Hydra: isComplexVariable :: Graph -> Name -> Bool
+ Hydra: isEncodedTerm :: Term -> Bool
+ Hydra: isEncodedType :: Term -> Bool
+ Hydra: isEnumRowType :: [FieldType] -> Bool
+ Hydra: isEnumType :: Type -> Bool
+ Hydra: isFreeVariableInTerm :: Name -> Term -> Bool
+ Hydra: isLambda :: Term -> Bool
+ Hydra: isNativeType :: Binding -> Bool
+ Hydra: isNominalType :: Type -> Bool
+ Hydra: isSelfTailRecursive :: Name -> Term -> Bool
+ Hydra: isSerializable :: t0 -> Graph -> Binding -> Either Error Bool
+ Hydra: isSerializableByName :: t0 -> Graph -> Name -> Either Error Bool
+ Hydra: isSerializableType :: Type -> Bool
+ Hydra: isSimpleAssignment :: Term -> Bool
+ Hydra: isTailRecursiveInTailPosition :: Name -> Term -> Bool
+ Hydra: isTrivialTerm :: Term -> Bool
+ Hydra: isType :: Type -> Bool
+ Hydra: isUnbound :: Graph -> Name -> Bool
+ Hydra: isUnitTerm :: Term -> Bool
+ Hydra: isUnitType :: Type -> Bool
+ Hydra: javaStyleComment :: String -> String
+ Hydra: joinTypes :: t0 -> Type -> Type -> String -> Either UnificationError [TypeConstraint]
+ Hydra: keyClasses :: Name
+ Hydra: keyDebugId :: Name
+ Hydra: keyDeprecated :: Name
+ Hydra: keyDescription :: Name
+ Hydra: keyExclude :: Name
+ Hydra: keyFirstClassType :: Name
+ Hydra: keyFreshTypeVariableCount :: Name
+ Hydra: keyMaxLength :: Name
+ Hydra: keyMinLength :: Name
+ Hydra: keyPreserveFieldName :: Name
+ Hydra: keyType :: Name
+ Hydra: liftLambdaAboveLet :: Term -> Term
+ Hydra: lines :: String -> [String]
+ Hydra: literalType :: Literal -> LiteralType
+ Hydra: literalTypeSupported :: LanguageConstraints -> LiteralType -> Bool
+ Hydra: literalTypeVariant :: LiteralType -> LiteralVariant
+ Hydra: literalTypes :: [LiteralType]
+ Hydra: literalVariant :: Literal -> LiteralVariant
+ Hydra: literalVariants :: [LiteralVariant]
+ Hydra: localNameOf :: Name -> String
+ Hydra: lookupBinding :: Graph -> Name -> Maybe Binding
+ Hydra: lookupPrimitive :: Graph -> Name -> Maybe Primitive
+ Hydra: lookupTerm :: Graph -> Name -> Maybe Term
+ Hydra: mapBeneathTypeAnnotations :: (Type -> Type) -> Type -> Type
+ Hydra: mapConstraints :: InferenceContext -> Graph -> (TypeSubst -> t0) -> [TypeConstraint] -> Either Error t0
+ Hydra: mapFirstLetter :: (String -> String) -> String -> String
+ Hydra: mapKeyResolvesToString :: Map Name Type -> Type -> Bool
+ Hydra: matchEnum :: Graph -> Name -> [(Name, t0)] -> Term -> Either Error t0
+ Hydra: matchRecord :: t0 -> (Map Name Term -> Either Error t1) -> Term -> Either Error t1
+ Hydra: matchUnion :: Graph -> Name -> [(Name, Term -> Either Error t0)] -> Term -> Either Error t0
+ Hydra: matchUnitField :: t0 -> t1 -> (t0, t2 -> Either t3 t1)
+ Hydra: maxInt32 :: Int
+ Hydra: maxLineWidth :: Int
+ Hydra: maxTraceDepth :: Int
+ Hydra: mergeClassConstraints :: Ord t0 => Map t0 TypeVariableConstraints -> Map t0 TypeVariableConstraints -> Map t0 TypeVariableConstraints
+ Hydra: moduleContainsBinaryLiterals :: Module -> Bool
+ Hydra: moduleContainsDecimalLiterals :: Module -> Bool
+ Hydra: moduleDependencyModuleNames :: t0 -> Graph -> Bool -> Bool -> Bool -> Bool -> Module -> Either Error (Set ModuleName)
+ Hydra: moduleNameOf :: Name -> Maybe ModuleName
+ Hydra: moduleNameToFilePath :: CaseConvention -> FileExtension -> ModuleName -> String
+ Hydra: moduleNamesForDefinitions :: (ModuleName -> t0) -> ModuleName -> [Definition] -> ModuleNames t0
+ Hydra: nameToFilePath :: CaseConvention -> CaseConvention -> FileExtension -> Name -> String
+ Hydra: nameToUpperDashed :: Name -> String
+ Hydra: newlineSep :: [Expr] -> Expr
+ Hydra: newtype ColumnName
+ Hydra: newtype DataRow v
+ Hydra: newtype DecodingError
+ Hydra: newtype HeaderRow
+ Hydra: newtype LanguageName
+ Hydra: newtype ModuleName
+ Hydra: newtype Name
+ Hydra: newtype OtherError
+ Hydra: newtype OtherResolutionError
+ Hydra: newtype PackageName
+ Hydra: newtype Parser a
+ Hydra: newtype PrimaryKey
+ Hydra: newtype Relation v
+ Hydra: newtype RelationName
+ Hydra: newtype Relationship v
+ Hydra: newtype Row v
+ Hydra: newtype SubtermPath
+ Hydra: newtype SubtypePath
+ Hydra: newtype Tag
+ Hydra: newtype TermSubst
+ Hydra: newtype TypeSubst
+ Hydra: newtype TypedName a
+ Hydra: newtype TypedTerm a
+ Hydra: newtype Variable
+ Hydra: newtype Version
+ Hydra: noPadding :: Padding
+ Hydra: noSep :: [Expr] -> Expr
+ Hydra: nominalApplication :: Name -> [Type] -> Type
+ Hydra: nonAlnumToUnderscores :: String -> String
+ Hydra: normalTypeVariable :: Int -> Name
+ Hydra: normalizeComment :: String -> String
+ Hydra: normalizeTermAnnotations :: Term -> Term
+ Hydra: normalizeTypeAnnotations :: Type -> Type
+ Hydra: normalizeTypeFreeVars :: Type -> Type
+ Hydra: normalizeTypeVariablesInTerm :: Term -> Term
+ Hydra: num :: Int -> Expr
+ Hydra: op :: String -> Int -> Associativity -> Op
+ Hydra: orOp :: Bool -> Op
+ Hydra: orSep :: BlockStyle -> [Expr] -> Expr
+ Hydra: parenList :: Bool -> [Expr] -> Expr
+ Hydra: parenListAdaptive :: [Expr] -> Expr
+ Hydra: parens :: Expr -> Expr
+ Hydra: parentheses :: Brackets
+ Hydra: parenthesize :: Expr -> Expr
+ Hydra: partitionDefinitions :: [Definition] -> ([TypeDefinition], [TermDefinition])
+ Hydra: popStackUntil :: Int -> TarjanState -> ([Int], TarjanState)
+ Hydra: prefix :: String -> Expr -> Expr
+ Hydra: prepareFloatType :: Ord t0 => FloatType -> (FloatType, (FloatValue -> FloatValue, Set t0))
+ Hydra: prepareIntegerType :: IntegerType -> (IntegerType, (IntegerValue -> IntegerValue, Set String))
+ Hydra: prepareLiteralType :: LiteralType -> (LiteralType, (Literal -> Literal, Set String))
+ Hydra: prepareSame :: Ord t2 => t0 -> (t0, (t1 -> t1, Set t2))
+ Hydra: prepareType :: t0 -> Type -> (Type, (Term -> Term, Set String))
+ Hydra: primitiveArity :: Primitive -> Int
+ Hydra: printExpr :: Expr -> String
+ Hydra: propagateTags :: (Ord t0, Ord t1) => [(t0, [t0])] -> [(t0, [t1])] -> [(t0, Set t1)]
+ Hydra: pruneLet :: Let -> Let
+ Hydra: pushSubtermStep :: SubtermStep -> InferenceContext -> InferenceContext
+ Hydra: pushTypeAppsInward :: Term -> Term
+ Hydra: qname :: ModuleName -> String -> Name
+ Hydra: qualifyName :: Name -> QualifiedName
+ Hydra: reduceTerm :: t0 -> Graph -> Bool -> Term -> Either Error Term
+ Hydra: regexCamelCase :: String
+ Hydra: regexNamespace :: String
+ Hydra: regexPackageName :: String
+ Hydra: regexPascalCase :: String
+ Hydra: removeTermAnnotations :: Term -> Term
+ Hydra: removeTypeAnnotations :: Type -> Type
+ Hydra: removeTypeAnnotationsFromTerm :: Term -> Term
+ Hydra: removeTypesFromTerm :: Term -> Term
+ Hydra: reorderDefs :: [Definition] -> [Definition]
+ Hydra: replaceFreeTermVariable :: Name -> Term -> Term -> Term
+ Hydra: replaceFreeTypeVariable :: Name -> Type -> Type -> Type
+ Hydra: replaceTypedefs :: Map Name TypeScheme -> Type -> Type
+ Hydra: requireBinding :: Graph -> Name -> Either Error Binding
+ Hydra: requirePrimitive :: Graph -> Name -> Either Error Primitive
+ Hydra: requirePrimitiveType :: Graph -> Name -> Either Error TypeScheme
+ Hydra: requireRecordType :: t0 -> Graph -> Name -> Either Error [FieldType]
+ Hydra: requireRowType :: t0 -> String -> (Type -> Maybe t1) -> Graph -> Name -> Either Error t1
+ Hydra: requireSchemaType :: InferenceContext -> Map Name TypeScheme -> Name -> Either Error (TypeScheme, InferenceContext)
+ Hydra: requireTerm :: Graph -> Name -> Either Error Term
+ Hydra: requireType :: t0 -> Graph -> Name -> Either Error Type
+ Hydra: requireUnionField :: t0 -> Graph -> Name -> Name -> Either Error Type
+ Hydra: requireUnionType :: t0 -> Graph -> Name -> Either Error [FieldType]
+ Hydra: resolveBaseType :: Map Name Type -> Type -> Type
+ Hydra: resolveTerm :: Graph -> Name -> Maybe Term
+ Hydra: resolveType :: Graph -> Type -> Maybe Type
+ Hydra: restoreTrace :: InferenceContext -> InferenceContext -> InferenceContext
+ Hydra: rewriteAndFoldTerm :: ((t0 -> Term -> (t0, Term)) -> t0 -> Term -> (t0, Term)) -> t0 -> Term -> (t0, Term)
+ Hydra: rewriteAndFoldTermWithGraph :: ((t0 -> Term -> (t0, Term)) -> Graph -> t0 -> Term -> (t0, Term)) -> Graph -> t0 -> Term -> (t0, Term)
+ Hydra: rewriteAndFoldTermWithGraphAndPath :: ((t0 -> Term -> (t0, Term)) -> [SubtermStep] -> Graph -> t0 -> Term -> (t0, Term)) -> Graph -> t0 -> Term -> (t0, Term)
+ Hydra: rewriteAndFoldTermWithPath :: (([SubtermStep] -> t0 -> Term -> (t0, Term)) -> [SubtermStep] -> t0 -> Term -> (t0, Term)) -> t0 -> Term -> (t0, Term)
+ Hydra: rewriteTerm :: ((Term -> Term) -> Term -> Term) -> Term -> Term
+ Hydra: rewriteTermM :: ((Term -> Either t0 Term) -> Term -> Either t0 Term) -> Term -> Either t0 Term
+ Hydra: rewriteTermWithContext :: ((t0 -> Term -> Term) -> t0 -> Term -> Term) -> t0 -> Term -> Term
+ Hydra: rewriteTermWithContextM :: ((t0 -> Term -> Either t1 Term) -> t0 -> Term -> Either t1 Term) -> t0 -> Term -> Either t1 Term
+ Hydra: rewriteTermWithGraph :: ((Term -> t0) -> Graph -> Term -> t0) -> Graph -> Term -> t0
+ Hydra: rewriteType :: ((Type -> Type) -> Type -> Type) -> Type -> Type
+ Hydra: rewriteTypeM :: ((Type -> Either t0 Type) -> Type -> Either t0 Type) -> Type -> Either t0 Type
+ Hydra: sanitizeWithUnderscores :: Set String -> String -> String
+ Hydra: schemaGraphToDefinitions :: LanguageConstraints -> Graph -> [[Name]] -> t0 -> Either Error (Map Name Type, [[TypeDefinition]])
+ Hydra: schemaGraphToTypingEnvironment :: Graph -> Either Error (Map Name TypeScheme)
+ Hydra: semicolonSep :: [Expr] -> Expr
+ Hydra: sep :: Op -> [Expr] -> Expr
+ Hydra: setAnnotation :: Ord t0 => t0 -> Maybe t1 -> Map t0 t1 -> Map t0 t1
+ Hydra: setDescription :: Maybe String -> Map Name Term -> Map Name Term
+ Hydra: setTermAnnotation :: Name -> Maybe Term -> Term -> Term
+ Hydra: setTermDescription :: Maybe String -> Term -> Term
+ Hydra: setType :: Maybe Type -> Map Name Term -> Map Name Term
+ Hydra: setTypeAnnotation :: Name -> Maybe Term -> Type -> Type
+ Hydra: setTypeClasses :: Map Name (Set Name) -> Term -> Term
+ Hydra: setTypeDescription :: Maybe String -> Type -> Type
+ Hydra: showInferenceResult :: InferenceResult -> String
+ Hydra: showList :: (t0 -> String) -> [t0] -> String
+ Hydra: simpleLanguageAdapter :: Language -> t0 -> Graph -> Type -> Either Error (Adapter Type Type Term Term Error)
+ Hydra: simplifyTerm :: Term -> Term
+ Hydra: singletonTypeSubst :: Name -> Type -> TypeSubst
+ Hydra: spaceSep :: [Expr] -> Expr
+ Hydra: spaceSepAdaptive :: [Expr] -> Expr
+ Hydra: squareBrackets :: Brackets
+ Hydra: stripAndDereferenceTerm :: Graph -> Term -> Either Error Term
+ Hydra: stripAndDereferenceTermEither :: Graph -> Term -> Either Error Term
+ Hydra: stripLeadingAndTrailingWhitespace :: String -> String
+ Hydra: stripTypeLambdas :: Term -> Term
+ Hydra: strongConnect :: Map Int [Int] -> Int -> TarjanState -> TarjanState
+ Hydra: stronglyConnectedComponents :: Map Int [Int] -> [[Int]]
+ Hydra: structuralSep :: Op -> [Expr] -> Expr
+ Hydra: structuralSpaceSep :: [Expr] -> Expr
+ Hydra: substInClassConstraints :: TypeSubst -> Map Name TypeVariableConstraints -> Map Name TypeVariableConstraints
+ Hydra: substInContext :: TypeSubst -> Graph -> Graph
+ Hydra: substInType :: TypeSubst -> Type -> Type
+ Hydra: substInTypeNonEmpty :: TypeSubst -> Type -> Type
+ Hydra: substInTypeScheme :: TypeSubst -> TypeScheme -> TypeScheme
+ Hydra: substTypesInTerm :: TypeSubst -> Term -> Term
+ Hydra: substituteInBinding :: TermSubst -> Binding -> Binding
+ Hydra: substituteInConstraint :: TypeSubst -> TypeConstraint -> TypeConstraint
+ Hydra: substituteInConstraints :: TypeSubst -> [TypeConstraint] -> [TypeConstraint]
+ Hydra: substituteInTerm :: TermSubst -> Term -> Term
+ Hydra: substituteTypeVariables :: Map Name Name -> Type -> Type
+ Hydra: substituteVariable :: Name -> Name -> Term -> Term
+ Hydra: substituteVariables :: Map Name Name -> Term -> Term
+ Hydra: subterms :: Term -> [Term]
+ Hydra: subtermsWithSteps :: Term -> [(SubtermStep, Term)]
+ Hydra: subtypes :: Type -> [Type]
+ Hydra: subtypesWithSteps :: Type -> [(SubtypeStep, Type)]
+ Hydra: suffix :: String -> Expr -> Expr
+ Hydra: sym :: String -> Symbol
+ Hydra: symbolSep :: String -> BlockStyle -> [Expr] -> Expr
+ Hydra: tabIndent :: Expr -> Expr
+ Hydra: tabIndentDoubleSpace :: [Expr] -> Expr
+ Hydra: tabIndentSingleSpace :: [Expr] -> Expr
+ Hydra: termAlternatives :: t0 -> Graph -> Term -> Either Error [Term]
+ Hydra: termAnnotationInternal :: Term -> Map Name Term
+ Hydra: termArity :: Term -> Int
+ Hydra: termAsBindings :: Term -> [Binding]
+ Hydra: termDependencyNames :: Bool -> Bool -> Bool -> Term -> Set Name
+ Hydra: termIsClosed :: Term -> Bool
+ Hydra: termIsValue :: Term -> Bool
+ Hydra: termSignatureToTypeScheme :: TermSignature -> TypeScheme
+ Hydra: termVariant :: Term -> TermVariant
+ Hydra: termVariants :: [TermVariant]
+ Hydra: toFContext :: Graph -> Map Name Type
+ Hydra: toShortNames :: [Name] -> Map Name Name
+ Hydra: topologicalSort :: Ord t0 => [(t0, [t0])] -> Either [[t0]] [t0]
+ Hydra: topologicalSortBindingMap :: Map Name Term -> [[(Name, Term)]]
+ Hydra: topologicalSortBindings :: [Binding] -> Either [[Name]] [Name]
+ Hydra: topologicalSortComponents :: Ord t0 => [(t0, [t0])] -> [[t0]]
+ Hydra: topologicalSortNodes :: Ord t1 => (t0 -> t1) -> (t0 -> [t1]) -> [t0] -> [[t0]]
+ Hydra: topologicalSortTypeDefinitions :: [TypeDefinition] -> [[TypeDefinition]]
+ Hydra: type EmptyListError = ()
+ Hydra: type NotEnoughCasesError = ()
+ Hydra: type SymmetricAdapter t v e = Adapter t t v v e
+ Hydra: type TypeAdapter = AdapterContext -> Type -> Either String SymmetricAdapter Type Term String
+ Hydra: typeAlternatives :: Type -> [Type]
+ Hydra: typeAnnotationInternal :: Type -> Map Name Term
+ Hydra: typeArity :: Type -> Int
+ Hydra: typeDependencies :: t0 -> Graph -> Bool -> (Type -> Type) -> Name -> Either Error (Map Name Type)
+ Hydra: typeDependencyNames :: Bool -> Type -> Set Name
+ Hydra: typeListsEffectivelyEqual :: Graph -> [Type] -> [Type] -> Bool
+ Hydra: typeNamesInType :: Ord t0 => Type -> Set t0
+ Hydra: typeOf :: InferenceContext -> Graph -> [Type] -> Term -> Either Error (Type, InferenceContext)
+ Hydra: typeOfAnnotatedTerm :: InferenceContext -> Graph -> [Type] -> AnnotatedTerm -> Either Error (Type, InferenceContext)
+ Hydra: typeOfApplication :: InferenceContext -> Graph -> [Type] -> Application -> Either Error (Type, InferenceContext)
+ Hydra: typeOfCaseStatement :: InferenceContext -> Graph -> [Type] -> CaseStatement -> Either Error (Type, InferenceContext)
+ Hydra: typeOfEither :: InferenceContext -> Graph -> [Type] -> Either Term Term -> Either Error (Type, InferenceContext)
+ Hydra: typeOfInjection :: InferenceContext -> Graph -> [Type] -> Injection -> Either Error (Type, InferenceContext)
+ Hydra: typeOfLambda :: InferenceContext -> Graph -> [Type] -> Lambda -> Either Error (Type, InferenceContext)
+ Hydra: typeOfLet :: InferenceContext -> Graph -> [Type] -> Let -> Either Error (Type, InferenceContext)
+ Hydra: typeOfList :: InferenceContext -> Graph -> [Type] -> [Term] -> Either Error (Type, InferenceContext)
+ Hydra: typeOfLiteral :: InferenceContext -> Graph -> [Type] -> Literal -> Either Error (Type, InferenceContext)
+ Hydra: typeOfMap :: InferenceContext -> Graph -> [Type] -> Map Term Term -> Either Error (Type, InferenceContext)
+ Hydra: typeOfMaybe :: InferenceContext -> Graph -> [Type] -> Maybe Term -> Either Error (Type, InferenceContext)
+ Hydra: typeOfPair :: InferenceContext -> Graph -> [Type] -> (Term, Term) -> Either Error (Type, InferenceContext)
+ Hydra: typeOfPrimitive :: InferenceContext -> Graph -> [Type] -> Name -> Either Error (Type, InferenceContext)
+ Hydra: typeOfProjection :: InferenceContext -> Graph -> [Type] -> Projection -> Either Error (Type, InferenceContext)
+ Hydra: typeOfRecord :: InferenceContext -> Graph -> [Type] -> Record -> Either Error (Type, InferenceContext)
+ Hydra: typeOfSet :: InferenceContext -> Graph -> [Type] -> Set Term -> Either Error (Type, InferenceContext)
+ Hydra: typeOfTerm :: InferenceContext -> Graph -> Term -> Either Error Type
+ Hydra: typeOfTypeApplication :: InferenceContext -> Graph -> [Type] -> TypeApplicationTerm -> Either Error (Type, InferenceContext)
+ Hydra: typeOfTypeLambda :: InferenceContext -> Graph -> [Type] -> TypeLambda -> Either Error (Type, InferenceContext)
+ Hydra: typeOfUnit :: InferenceContext -> Graph -> [Type] -> Either Error (Type, InferenceContext)
+ Hydra: typeOfUnwrap :: InferenceContext -> Graph -> [Type] -> Name -> Either Error (Type, InferenceContext)
+ Hydra: typeOfVariable :: InferenceContext -> Graph -> [Type] -> Name -> Either Error (Type, InferenceContext)
+ Hydra: typeOfWrappedTerm :: InferenceContext -> Graph -> [Type] -> WrappedTerm -> Either Error (Type, InferenceContext)
+ Hydra: typeSchemeArity :: TypeScheme -> Int
+ Hydra: typeSchemeToFType :: TypeScheme -> Type
+ Hydra: typeSchemeToTermSignature :: TypeScheme -> TermSignature
+ Hydra: typeToTypeScheme :: Type -> TypeScheme
+ Hydra: typeVariant :: Type -> TypeVariant
+ Hydra: typeVariants :: [TypeVariant]
+ Hydra: typesAllEffectivelyEqual :: Graph -> [Type] -> Bool
+ Hydra: typesEffectivelyEqual :: Graph -> Type -> Type -> Bool
+ Hydra: typesToDefinitions :: Map Name Type -> [Binding]
+ Hydra: uncurryType :: Type -> [Type]
+ Hydra: unifyTypeConstraints :: t0 -> Map Name TypeScheme -> [TypeConstraint] -> Either UnificationError TypeSubst
+ Hydra: unifyTypeLists :: t0 -> Map Name TypeScheme -> [Type] -> [Type] -> String -> Either UnificationError TypeSubst
+ Hydra: unifyTypes :: t0 -> Map Name TypeScheme -> Type -> Type -> String -> Either UnificationError TypeSubst
+ Hydra: unlines :: [String] -> String
+ Hydra: unqualifyName :: QualifiedName -> Name
+ Hydra: unshadowVariables :: Term -> Term
+ Hydra: unsupportedType :: String -> Expr
+ Hydra: unsupportedVariant :: String -> String -> Expr
+ Hydra: variableOccursInType :: Name -> Type -> Bool
+ Hydra: warningAutoGeneratedFile :: String
+ Hydra: withCharacterAliases :: String -> String
+ Hydra: withComma :: Expr -> Expr
+ Hydra: withLambdaContext :: (t0 -> Graph) -> (Graph -> t0 -> t1) -> t0 -> Lambda -> (t1 -> t2) -> t2
+ Hydra: withLetContext :: (t0 -> Graph) -> (Graph -> t0 -> t1) -> (Graph -> Binding -> Maybe Term) -> t0 -> Let -> (t1 -> t2) -> t2
+ Hydra: withSemi :: Expr -> Expr
+ Hydra: withTypeLambdaContext :: (t0 -> Graph) -> (Graph -> t0 -> t1) -> t0 -> TypeLambda -> (t1 -> t2) -> t2
+ Hydra: wrapAnnotationMap :: Map Name Term -> Term
+ Hydra: wrapLine :: Int -> String -> String
+ Hydra: wrapTermToRecord :: Name -> Term -> Term
+ Hydra: wrapTypeToRecord :: Type -> Type
+ Hydra: yield :: InferenceContext -> Term -> Type -> TypeSubst -> InferenceResult
+ Hydra: yieldChecked :: InferenceContext -> Term -> Type -> TypeSubst -> InferenceResult
+ Hydra: yieldCheckedWithConstraints :: InferenceContext -> Term -> Type -> TypeSubst -> Map Name TypeVariableConstraints -> InferenceResult
+ Hydra: yieldWithConstraints :: InferenceContext -> Term -> Type -> TypeSubst -> Map Name TypeVariableConstraints -> InferenceResult

Files

CHANGELOG.md view
@@ -15,6 +15,86 @@  --- +## [0.18.0] - 2026-09-29++Module-naming systematization release: every kernel and package module moves onto a uniform+`hydra.core.*` / `hydra.<pkg>.*` grammar, completing the package ⊃ module ⊃ definition containment+tower. The rename touches every module, definition, and cross-host reference in the codebase; this+release exists primarily to ship it as its own coordinated batch. Also lands the translingual regex+primitive pipeline and several silent-correctness fixes in the coder layer.++### Highlights++- **Module-name grammar systematization** ([#729](https://github.com/CategoricalData/hydra/issues/729)):+  every `hydra.*` module renamed onto a uniform package-derived prefix — kernel modules move to+  `hydra.core.*`, package modules to `hydra.<pkg>.*` — closing the long-standing inconsistency where+  a package name had no structural relationship to the module names it contained. The rename spans+  every host (Haskell, Java, Python, Scala, TypeScript, all four Lisp dialects) and required fixing+  stale namespace references, overlay-directory paths, and `hostOverrides` shims across every driver+  and bootstrap script that had hardcoded the old grammar. Further consolidation (a structurally+  enforced package↔prefix law) is tracked for 0.18.1. The kernel package itself is still published as+  `hydra-kernel` (its modules are under `hydra.core.*`); the `hydra-core` package rename #729 called for+  is under review because that name is taken on PyPI and npm+  ([#770](https://github.com/CategoricalData/hydra/issues/770)).+- **Translingual regex primitives** ([#603](https://github.com/CategoricalData/hydra/issues/603)):+  `hydra.lib.regex` primitives (`find`, `findAll`, `matches`, `replace`, `replaceAll`, `split`) now run+  every pattern through the shared `hydra.regex` parse/print pipeline instead of handing raw pattern+  strings to each host's native engine, so a pattern means the same thing on every host. Includes a+  host-independent conformance suite and a leftmost-longest alternation fix in the PCRE/POSIX printers.+- **Silent-corruption fixes across the coder layer**+  ([#744](https://github.com/CategoricalData/hydra/issues/744),+  [#765](https://github.com/CategoricalData/hydra/issues/765),+  [#649](https://github.com/CategoricalData/hydra/issues/649)): fixed data-corrupting bugs in the+  JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the+  kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and+  the Python coder (silently dropping a module's types when types and terms share a file path).+- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)):+  the module-reference pages under `docs/specification/` are now generated directly from the kernel+  (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained.++### New features++- **[#603](https://github.com/CategoricalData/hydra/issues/603)** host-independent regex conformance+  suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors,+  grouping) across all 9 hosts.+- **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and+  `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages.+- **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of+  `hydra-ext` into its own first-class `hydra-rust` package.++### Bug fixes++- **[#744](https://github.com/CategoricalData/hydra/issues/744)** silent data corruption in+  JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders for extended integer widths and map-key handling.+- **[#765](https://github.com/CategoricalData/hydra/issues/765)** kernel encode/decode generators+  emitted reversed type-parameter order for 2+-param polymorphic types.+- **[#649](https://github.com/CategoricalData/hydra/issues/649)** Python coder silently dropped a+  module's types when types and terms targeted the same output file path.+- **[#572](https://github.com/CategoricalData/hydra/issues/572)** TypeScript kernel-JSON test+  bridge's compact-form decode heuristic mishandled nullary union arms.+- **[#761](https://github.com/CategoricalData/hydra/issues/761)** cold-seed generation ignored+  `hostOverrides.java=local`, silently pulling the published Java host jar instead.+- **[#736](https://github.com/CategoricalData/hydra/issues/736)** Java build now pins JDK 11 via a+  Gradle toolchain block, instead of depending on ambient `JAVA_HOME`.++### Improvements++- **[#327](https://github.com/CategoricalData/hydra/issues/327)** new `hydra.diff` schema-diff type+  module; `Term.Inject` comparison is now by variant name.+- **[#573](https://github.com/CategoricalData/hydra/issues/573)** per-registry publish sets (Hackage,+  Maven, PyPI, npm) are now derived from the package registry itself instead of 13 hand-maintained+  lists — closes a recurring class of silent release-time drift.+- **[#735](https://github.com/CategoricalData/hydra/issues/735)** cross-host decimal-scale test+  filtering now driven by a translingual `scaleDistinct` capability tag instead of hand-copied+  per-host skip lists.++### Documentation++- **[#655](https://github.com/CategoricalData/hydra/issues/655)** documented the overlay-emission+  "implementation wins" decision for bare primitive references (`docs/overlays.md`).++---+ ## [0.17.7] - 2026-09-14  Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It
hydra.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-version:        0.17.7+version:        0.18.0 synopsis:       Hydra: graphs are programs, and programs are graphs (umbrella package) description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". This umbrella package provides a single convenient entry point (the Hydra module) re-exporting the Hydra kernel plus the Haskell coder's moduleToHaskell. Depend on hydra-kernel / hydra-haskell directly for finer-grained APIs. category:       Data@@ -34,6 +34,6 @@       src/main/haskell   build-depends:       base >=4.19.0 && <4.22-    , hydra-haskell ==0.17.7-    , hydra-kernel ==0.17.7+    , hydra-haskell ==0.18.0+    , hydra-kernel ==0.18.0   default-language: Haskell2010
src/main/haskell/Hydra.hs view
@@ -12,7 +12,7 @@ -- | The surface here is deliberately small. Everything else in the kernel and -- | the Haskell coder remains available by direct, qualified import — e.g. -- | @import qualified Hydra.Haskell.Syntax as H@ for the Haskell AST types, or--- | @import Hydra.Ast@ for the modules "Hydra.Kernel" omits to avoid name+-- | @import Hydra.Core.Ast@ for the modules "Hydra.Kernel" omits to avoid name -- | clashes. Depend on @hydra-kernel@ / @hydra-haskell@ directly for -- | finer-grained APIs. --