hydra-0.15.0: src/main/haskell/Hydra/Sources/Haskell/Coder.hs
module Hydra.Sources.Haskell.Coder where
-- Standard imports for term-level sources outside of the kernel
import Hydra.Kernel
import Hydra.Sources.Libraries
import Hydra.Dsl.Meta.Lib.Strings as Strings
import Hydra.Dsl.Meta.Phantoms as Phantoms
import qualified Hydra.Dsl.Annotations as Annotations
import qualified Hydra.Dsl.Bootstrap as Bootstrap
import qualified Hydra.Dsl.LiteralTypes as LiteralTypes
import qualified Hydra.Dsl.Literals as Literals
import qualified Hydra.Dsl.Paths as Paths
import qualified Hydra.Dsl.Ast as Ast
import qualified Hydra.Dsl.Meta.Base as MetaBase
import qualified Hydra.Dsl.Coders as Coders
import qualified Hydra.Dsl.Util as Util
import qualified Hydra.Dsl.Meta.Core as Core
import qualified Hydra.Dsl.Meta.Graph as Graph
import qualified Hydra.Dsl.Json.Model as Json
import qualified Hydra.Dsl.Meta.Lib.Chars as Chars
import qualified Hydra.Dsl.Meta.Lib.Eithers as Eithers
import qualified Hydra.Dsl.Meta.Lib.Equality as Equality
import qualified Hydra.Dsl.Meta.Lib.Lists as Lists
import qualified Hydra.Dsl.Meta.Lib.Literals as Literals
import qualified Hydra.Dsl.Meta.Lib.Logic as Logic
import qualified Hydra.Dsl.Meta.Lib.Maps as Maps
import qualified Hydra.Dsl.Meta.Lib.Math as Math
import qualified Hydra.Dsl.Meta.Lib.Maybes as Maybes
import qualified Hydra.Dsl.Meta.Lib.Pairs as Pairs
import qualified Hydra.Dsl.Meta.Lib.Sets as Sets
import qualified Hydra.Dsl.Packaging as Packaging
import qualified Hydra.Dsl.Meta.Terms as MetaTerms
import qualified Hydra.Dsl.Meta.Testing as Testing
import qualified Hydra.Dsl.Topology as Topology
import qualified Hydra.Dsl.Meta.Types as MetaTypes
import qualified Hydra.Dsl.Typing as Typing
import qualified Hydra.Dsl.Util as Util
import qualified Hydra.Dsl.Meta.Variants as Variants
import qualified Hydra.Dsl.Meta.Context as Ctx
import qualified Hydra.Dsl.Errors as Error
import qualified Hydra.Dsl.Prims as Prims
import qualified Hydra.Dsl.Meta.Tabular as Tabular
import qualified Hydra.Dsl.Terms as Terms
import qualified Hydra.Dsl.Tests as Tests
import qualified Hydra.Dsl.Types as Types
import qualified Hydra.Sources.Decode.Core as DecodeCore
import qualified Hydra.Sources.Encode.Core as EncodeCore
import qualified Hydra.Sources.Kernel.Terms.Adapt as Adapt
import qualified Hydra.Sources.Kernel.Terms.All as KernelTerms
import qualified Hydra.Sources.Kernel.Terms.Annotations as Annotations
import qualified Hydra.Sources.Kernel.Terms.Arity as Arity
import qualified Hydra.Sources.Kernel.Terms.Checking as Checking
import qualified Hydra.Sources.Kernel.Terms.Constants as Constants
import qualified Hydra.Sources.Kernel.Terms.Extract.Core as ExtractCore
import qualified Hydra.Sources.Kernel.Terms.Extract.Util as ExtractUtil
import qualified Hydra.Sources.Kernel.Terms.Formatting as Formatting
import qualified Hydra.Sources.Kernel.Terms.Inference as Inference
import qualified Hydra.Sources.Kernel.Terms.Languages as Languages
import qualified Hydra.Sources.Kernel.Terms.Lexical as Lexical
import qualified Hydra.Sources.Kernel.Terms.Literals as Literals
import qualified Hydra.Sources.Kernel.Terms.Names as Names
import qualified Hydra.Sources.Kernel.Terms.Reduction as Reduction
import qualified Hydra.Sources.Kernel.Terms.Reflect as Reflect
import qualified Hydra.Sources.Kernel.Terms.Dependencies as Dependencies
import qualified Hydra.Sources.Kernel.Terms.Rewriting as Rewriting
import qualified Hydra.Sources.Kernel.Terms.Analysis as Analysis
import qualified Hydra.Sources.Kernel.Terms.Predicates as Predicates
import qualified Hydra.Sources.Kernel.Terms.Resolution as Resolution
import qualified Hydra.Sources.Kernel.Terms.Strip as Strip
import qualified Hydra.Sources.Kernel.Terms.Variables as Variables
import qualified Hydra.Sources.Kernel.Terms.Serialization as Serialization
import qualified Hydra.Sources.Kernel.Terms.Show.Paths as ShowPaths
import qualified Hydra.Sources.Kernel.Terms.Show.Core as ShowCore
import qualified Hydra.Sources.Kernel.Terms.Show.Graph as ShowGraph
import qualified Hydra.Sources.Kernel.Terms.Show.Variants as ShowVariants
import qualified Hydra.Sources.Kernel.Terms.Show.Typing as ShowTyping
import qualified Hydra.Sources.Kernel.Terms.Sorting as Sorting
import qualified Hydra.Sources.Kernel.Terms.Substitution as Substitution
import qualified Hydra.Sources.Kernel.Terms.Templates as Templates
import qualified Hydra.Sources.Kernel.Terms.Unification as Unification
import qualified Hydra.Sources.Kernel.Types.All as KernelTypes
import Prelude hiding ((++))
import qualified Data.Int as I
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Maybe as Y
-- Additional imports
import qualified Hydra.Haskell.Environment as HE
import qualified Hydra.Haskell.Syntax as H
import qualified Hydra.Sources.Haskell.Environment as HaskellEnvironment
import qualified Hydra.Sources.Haskell.Language as HaskellLanguage
import qualified Hydra.Sources.Haskell.Syntax as HaskellSyntax
import qualified Hydra.Sources.Haskell.Serde as HaskellSerde
import qualified Hydra.Sources.Haskell.Utils as HaskellUtils
import qualified Hydra.Sources.Kernel.Terms.Show.Errors as ShowError
formatError :: TTerm (Error -> String)
formatError = "e" ~> ShowError.error_ @@ var "e"
-- | Lift Either String to Either Error using a context
liftStringError :: TTerm Context -> TTerm (Either String a) -> TTerm (Either Error a)
liftStringError cx = Eithers.bimap ("_s" ~> Ctx.inContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "valid input") (var "_s")) cx) ("_x" ~> var "_x")
type HaskellNamespaces = Namespaces H.ModuleName
haskellCoderDefinition :: String -> TTerm a -> TTermDefinition a
haskellCoderDefinition = definitionInModule module_
module_ :: Module
module_ = Module {
moduleNamespace = ns,
moduleDefinitions = definitions,
moduleTermDependencies = [HaskellSerde.ns, HaskellUtils.ns,
Adapt.ns, Analysis.ns, Dependencies.ns, Predicates.ns, Resolution.ns, Rewriting.ns, Serialization.ns, ShowError.ns, Strip.ns, Variables.ns],
moduleTypeDependencies = (HaskellEnvironment.ns:HaskellSyntax.ns:KernelTypes.kernelTypesNamespaces),
moduleDescription = Just "Functions for encoding Hydra modules as Haskell modules"}
where
ns = Namespace "hydra.haskell.coder"
definitions = [
toDefinition includeTypeDefinitions,
toDefinition useCoreImport,
toDefinition keyHaskellVar,
toDefinition adaptTypeToHaskellAndEncode,
toDefinition constantForFieldName,
toDefinition constantForTypeName,
toDefinition constructModule,
toDefinition emptyMetadata,
toDefinition encodeCaseExpression,
toDefinition encodeLambdaTerm,
toDefinition encodeLiteral,
toDefinition encodeProjection,
toDefinition encodeStandaloneCases,
toDefinition encodeTerm,
toDefinition encodeUnwrap,
toDefinition encodeType,
toDefinition encodeTypeWithClassAssertions,
toDefinition extendMetaForTerm,
toDefinition extendMetaForType,
toDefinition findOrdVariables,
toDefinition gatherMetadata,
toDefinition getImplicitTypeClasses,
toDefinition moduleToHaskellModule,
toDefinition moduleToHaskell,
toDefinition nameDecls,
toDefinition setMetaUsesByteString,
toDefinition setMetaUsesInt,
toDefinition setMetaUsesMap,
toDefinition setMetaUsesSet,
toDefinition toDataDeclaration,
-- toDefinition toTypeDeclarations,
toDefinition toTypeDeclarationsFrom,
toDefinition typeDecl,
toDefinition typeSchemeConstraintsToClassMap]
-- TODO: make these settings configurable
includeTypeDefinitions :: TTermDefinition Bool
includeTypeDefinitions = haskellCoderDefinition "includeTypeDefinitions" $
doc "Whether to include type definitions in generated Haskell modules" $
false
useCoreImport :: TTermDefinition Bool
useCoreImport = haskellCoderDefinition "useCoreImport" $
doc "Whether to use the Hydra core import in generated modules" $
true
keyHaskellVar :: TTermDefinition Name
keyHaskellVar = haskellCoderDefinition "keyHaskellVar" $
doc "The key used to track Haskell variable depth in annotations" $
wrap _Name $ string "haskellVar"
adaptTypeToHaskellAndEncode :: TTermDefinition (HaskellNamespaces -> Type -> Context -> Graph -> Either Error H.Type)
adaptTypeToHaskellAndEncode = haskellCoderDefinition "adaptTypeToHaskellAndEncode" $
doc "Adapt a Hydra type to Haskell's type system and encode it" $
"namespaces" ~> "typ" ~> "cx" ~> "g" ~>
"enc" <~ ("t" ~> encodeType @@ var "namespaces" @@ var "t" @@ var "cx" @@ var "g") $
cases _Type (Strip.deannotateType @@ var "typ")
(Just (
"adaptedType" <<~ Adapt.adaptTypeForLanguage @@ HaskellLanguage.haskellLanguage @@ var "typ" $
var "enc" @@ var "adaptedType")) [
_Type_variable>>: constant (var "enc" @@ var "typ")]
constantForFieldName :: TTermDefinition (Name -> Name -> String)
constantForFieldName = haskellCoderDefinition "constantForFieldName" $
doc "Generate a constant name for a field (e.g., '_TypeName_fieldName')" $
"tname" ~> "fname" ~>
Strings.cat $ list [
string "_",
Names.localNameOf @@ var "tname",
string "_",
Core.unName $ var "fname"]
constantForTypeName :: TTermDefinition (Name -> String)
constantForTypeName = haskellCoderDefinition "constantForTypeName" $
doc "Generate a constant name for a type (e.g., '_TypeName')" $
"tname" ~>
Strings.cat2 (string "_") (Names.localNameOf @@ var "tname")
constructModule :: TTermDefinition (HaskellNamespaces -> Module -> [Definition] -> Context -> Graph -> Either Error H.Module)
constructModule = haskellCoderDefinition "constructModule" $
doc "Construct a Haskell module from a Hydra module and its definitions" $
"namespaces" ~> "mod" ~> "defs" ~> "cx" ~> "g" ~> lets [
"h">: "namespace" ~>
unwrap _Namespace @@ var "namespace",
"createDeclarations">: "def" ~>
cases _Definition (var "def") Nothing [
_Definition_type>>: "type" ~> lets [
"name">: Packaging.typeDefinitionName $ var "type",
"typ">: Core.typeSchemeBody $ Packaging.typeDefinitionTypeScheme $ var "type"] $
toTypeDeclarationsFrom @@ var "namespaces" @@ var "name" @@ var "typ" @@ var "cx" @@ var "g",
_Definition_term>>: "term" ~>
"d" <<~ toDataDeclaration @@ var "namespaces" @@ var "term" @@ var "cx" @@ var "g" $
right $ list [var "d"]],
"importName">: "name" ~>
wrap H._ModuleName $ Strings.intercalate (string ".") (Lists.map (Formatting.capitalize) (Strings.splitOn (string ".") (var "name"))),
"imports">: Lists.concat2 (var "domainImports") (var "standardImports"),
"domainImports">: lets [
"toImport">: "pair" ~> lets [
"namespace">: Pairs.first $ var "pair",
"alias">: Pairs.second $ var "pair",
"name">: var "h" @@ var "namespace"] $
record H._Import [
H._Import_qualified>>: true,
H._Import_module>>: var "importName" @@ var "name",
H._Import_as>>: just $ var "alias",
H._Import_spec>>: nothing]] $
Lists.map (var "toImport") (Maps.toList $ Packaging.namespacesMapping $ var "namespaces"),
"meta">: gatherMetadata @@ var "defs",
"condImport">: "flag" ~> "triple" ~>
Logic.ifElse (var "flag")
(list [var "triple"])
(list ([] :: [TTerm ((String, Maybe String), [String])])),
"standardImports">: lets [
"toImport">: "triple" ~> lets [
"name">: Pairs.first $ Pairs.first $ var "triple",
"malias">: Pairs.second $ Pairs.first $ var "triple",
"hidden">: Pairs.second $ var "triple",
"spec">: Logic.ifElse (Lists.null $ var "hidden")
nothing
(just $ inject H._SpecImport H._SpecImport_hiding $ Lists.map ("n" ~> record H._ImportExportSpec [
H._ImportExportSpec_modifier>>: nothing,
H._ImportExportSpec_name>>: HaskellUtils.simpleName @@ var "n",
H._ImportExportSpec_subspec>>: nothing]) (var "hidden"))] $
record H._Import [
H._Import_qualified>>: Maybes.isJust $ var "malias",
H._Import_module>>: wrap H._ModuleName $ var "name",
H._Import_as>>: Maybes.map (unaryFunction $ wrap H._ModuleName) (var "malias"),
H._Import_spec>>: var "spec"]] $
Lists.map (var "toImport") $ Lists.concat $ list [
-- Prelude is always imported (hides names that conflict with Hydra)
list [
pair (pair (string "Prelude") nothing) (list $ string <$> [
"Enum", "Ordering", "decodeFloat", "encodeFloat", "fail", "map", "pure", "sum"])],
-- Data.Scientific is always imported (modules that don't use it produce an unused-import warning)
list [
pair (pair (string "Data.Scientific") (just $ string "Sci")) (list ([] :: [TTerm String]))],
-- Conditional standard imports based on metadata
var "condImport"
@@ (project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesByteString @@ var "meta")
@@ pair (pair (string "Data.ByteString") (just $ string "B")) (list ([] :: [TTerm String])),
var "condImport"
@@ (project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesInt @@ var "meta")
@@ pair (pair (string "Data.Int") (just $ string "I")) (list ([] :: [TTerm String])),
var "condImport"
@@ (project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesMap @@ var "meta")
@@ pair (pair (string "Data.Map") (just $ string "M")) (list ([] :: [TTerm String])),
var "condImport"
@@ (project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesSet @@ var "meta")
@@ pair (pair (string "Data.Set") (just $ string "S")) (list ([] :: [TTerm String])),
-- Conditionally add Hydra.Lib.Literals import if binary or decimal literals are present
Logic.ifElse (Logic.or
(Analysis.moduleContainsBinaryLiterals @@ var "mod")
(Analysis.moduleContainsDecimalLiterals @@ var "mod"))
(list [pair (pair (string "Hydra.Lib.Literals") (just $ string "Literals")) (list ([] :: [TTerm String]))])
(list ([] :: [TTerm ((String, Maybe String), [String])]))]] $
"declLists" <<~ Eithers.mapList (var "createDeclarations") (var "defs") $ lets [
"decls">: Lists.concat $ var "declLists",
"mc">: Packaging.moduleDescription $ var "mod"] $
right $ record H._Module [
H._Module_head>>: just $ record H._ModuleHead [
H._ModuleHead_comments>>: var "mc",
H._ModuleHead_name>>: var "importName" @@ (var "h" @@ (Packaging.moduleNamespace $ var "mod")),
H._ModuleHead_exports>>: list ([] :: [TTerm H.Export])],
H._Module_imports>>: var "imports",
H._Module_declarations>>: var "decls"]
emptyMetadata :: TTermDefinition HE.HaskellModuleMetadata
emptyMetadata = haskellCoderDefinition "emptyMetadata" $
doc "Create an initial empty metadata record with all flags set to false" $
record HE._HaskellModuleMetadata [
HE._HaskellModuleMetadata_usesByteString>>: false,
HE._HaskellModuleMetadata_usesInt>>: false,
HE._HaskellModuleMetadata_usesMap>>: false,
HE._HaskellModuleMetadata_usesSet>>: false]
encodeCaseExpression :: TTermDefinition (Int -> HaskellNamespaces -> CaseStatement -> H.Expression -> Context -> Graph -> Either Error H.Expression)
encodeCaseExpression = haskellCoderDefinition "encodeCaseExpression" $
doc "Encode a Hydra case statement as a Haskell case expression with a given scrutinee" $
"depth" ~> "namespaces" ~> "stmt" ~> "scrutinee" ~> "cx" ~> "g" ~> lets [
"dn">: Core.caseStatementTypeName $ var "stmt",
"def">: Core.caseStatementDefault $ var "stmt",
"fields">: Core.caseStatementCases $ var "stmt",
"toAlt">: "fieldMap" ~> "field" ~> lets [
"fn">: Core.fieldName $ var "field",
"fun'">: Core.fieldTerm $ var "field",
"v0">: Strings.cat2 (string "v") (Literals.showInt32 $ var "depth"),
"raw">: MetaTerms.apply (var "fun'") (Core.termVariable $ Core.name $ var "v0"),
"rhsTerm">: Dependencies.simplifyTerm @@ var "raw",
"v1">: Logic.ifElse (Variables.isFreeVariableInTerm @@ (wrap _Name $ var "v0") @@ var "rhsTerm")
(Constants.ignoredVariable)
(var "v0"),
"hname">: HaskellUtils.unionFieldReference @@ (Sets.union (Sets.fromList (Maps.keys (Graph.graphBoundTerms $ var "g"))) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes $ var "g")))) @@ var "namespaces" @@ var "dn" @@ var "fn"] $
"args" <<~ (Maybes.cases (Maps.lookup (var "fn") (var "fieldMap"))
(Ctx.failInContext (Error.errorResolution $ Error.resolutionErrorNoMatchingField $ Error.noMatchingFieldError (var "fn")) (var "cx")) $
"fieldType" ~> lets [
"ft">: Core.fieldTypeType $ var "fieldType",
"noArgs">: list ([] :: [TTerm H.Pattern]),
"singleArg">: list [inject H._Pattern H._Pattern_name $ HaskellUtils.rawName @@ var "v1"]] $
cases _Type (Strip.deannotateType @@ var "ft")
(Just $ right $ var "singleArg") [
_Type_unit>>: constant $ right $ var "noArgs"]) $ lets [
"lhs">: HaskellUtils.applicationPattern @@ var "hname" @@ var "args"] $
"rhs" <<~ Eithers.map (unaryFunction $ wrap H._CaseRhs) (encodeTerm @@ (Math.add (var "depth") (int32 1)) @@ var "namespaces" @@ var "rhsTerm" @@ var "cx" @@ var "g") $
right $ record H._Alternative [
H._Alternative_pattern>>: var "lhs",
H._Alternative_rhs>>: var "rhs",
H._Alternative_binds>>: nothing]] $
"rt" <<~ Resolution.requireUnionType @@ var "cx" @@ var "g" @@ var "dn" $ lets [
"toFieldMapEntry">: "f" ~>
pair (Core.fieldTypeName $ var "f") (var "f"),
"fieldMap">: Maps.fromList $ Lists.map (var "toFieldMapEntry") (var "rt")] $
"ecases" <<~ Eithers.mapList (var "toAlt" @@ var "fieldMap") (var "fields") $
"dcases" <<~ (Maybes.cases (var "def")
(right $ list ([] :: [TTerm H.CaseRhs])) $
"d" ~>
"cs" <<~ Eithers.map (unaryFunction $ wrap H._CaseRhs) (encodeTerm @@ var "depth" @@ var "namespaces" @@ var "d" @@ var "cx" @@ var "g") $ lets [
"lhs">: inject H._Pattern H._Pattern_name $ HaskellUtils.rawName @@ (Constants.ignoredVariable),
"alt">: record H._Alternative [
H._Alternative_pattern>>: var "lhs",
H._Alternative_rhs>>: var "cs",
H._Alternative_binds>>: nothing]] $
right $ list [var "alt"]) $
right $ inject H._Expression H._Expression_case $ record H._CaseExpression [
H._CaseExpression_case>>: var "scrutinee",
H._CaseExpression_alternatives>>: Lists.concat2 (var "ecases") (var "dcases")]
encodeUnwrap :: TTermDefinition (HaskellNamespaces -> Name -> Either Error H.Expression)
encodeUnwrap = haskellCoderDefinition "encodeUnwrap" $
doc "Encode an unwrap term as a Haskell expression" $
"namespaces" ~> "name" ~>
right $ inject H._Expression H._Expression_variable $ HaskellUtils.elementReference @@ var "namespaces" @@
(Names.qname @@ (Maybes.fromMaybe (wrap _Namespace $ string "") (Names.namespaceOf @@ var "name")) @@ (HaskellUtils.newtypeAccessorName @@ var "name"))
encodeProjection :: TTermDefinition (HaskellNamespaces -> Projection -> Either Error H.Expression)
encodeProjection = haskellCoderDefinition "encodeProjection" $
doc "Encode a record projection as a Haskell expression" $
"namespaces" ~> "proj" ~> lets [
"dn">: Core.projectionTypeName $ var "proj",
"fname">: Core.projectionField $ var "proj"] $
right $ inject H._Expression H._Expression_variable $ HaskellUtils.recordFieldReference @@ var "namespaces" @@ var "dn" @@ var "fname"
encodeLambdaTerm :: TTermDefinition (Int -> HaskellNamespaces -> Lambda -> Context -> Graph -> Either Error H.Expression)
encodeLambdaTerm = haskellCoderDefinition "encodeLambdaTerm" $
doc "Encode a Hydra lambda as a Haskell expression" $
"depth" ~> "namespaces" ~> "lam" ~> "cx" ~> "g" ~> lets [
"v">: Core.lambdaParameter $ var "lam",
"body">: Core.lambdaBody $ var "lam"] $
"hbody" <<~ encodeTerm @@ var "depth" @@ var "namespaces" @@ var "body" @@ var "cx" @@ var "g" $
right $ HaskellUtils.hslambda @@ (HaskellUtils.elementReference @@ var "namespaces" @@ var "v") @@ var "hbody"
encodeStandaloneCases :: TTermDefinition (Int -> HaskellNamespaces -> CaseStatement -> Context -> Graph -> Either Error H.Expression)
encodeStandaloneCases = haskellCoderDefinition "encodeStandaloneCases" $
doc "Encode a standalone (un-applied) case statement as a Haskell lambda over a case expression" $
"depth" ~> "namespaces" ~> "stmt" ~> "cx" ~> "g" ~>
-- When used standalone (not applied to an argument), wrap in a lambda
Eithers.map (HaskellUtils.hslambda @@ (HaskellUtils.rawName @@ string "x"))
(encodeCaseExpression @@ var "depth" @@ var "namespaces" @@ var "stmt" @@ (HaskellUtils.hsvar @@ string "x") @@ var "cx" @@ var "g")
encodeLiteral :: TTermDefinition (Literal -> Context -> Either Error H.Expression)
encodeLiteral = haskellCoderDefinition "encodeLiteral" $
doc "Encode a Hydra literal as a Haskell expression" $
"l" ~> "cx" ~>
cases _Literal (var "l")
(Just $ Ctx.failInContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "supported literal") (ShowCore.literal @@ var "l")) (var "cx")) [
_Literal_binary>>: "bs" ~>
right $ HaskellUtils.hsapp
@@ (HaskellUtils.hsvar @@ string "Literals.stringToBinary")
@@ (HaskellUtils.hslit @@ (inject H._Literal H._Literal_string
$ Literals.binaryToString $ var "bs")),
_Literal_boolean>>: "b" ~>
right $ HaskellUtils.hsvar @@ Logic.ifElse (var "b") (string "True") (string "False"),
_Literal_decimal>>: "d" ~>
right $ HaskellUtils.hsapp
@@ (HaskellUtils.hsvar @@ string "Literals.stringToDecimal")
@@ (HaskellUtils.hslit @@ (inject H._Literal H._Literal_string
$ Literals.showDecimal $ var "d")),
_Literal_float>>: "fv" ~>
cases _FloatValue (var "fv") Nothing [
_FloatValue_float32>>: "f" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_float $ var "f"),
_FloatValue_float64>>: "f" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_double $ var "f"),
_FloatValue_bigfloat>>: "f" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_double $ Literals.bigfloatToFloat64 $ var "f")],
_Literal_integer>>: "iv" ~>
cases _IntegerValue (var "iv") Nothing [
_IntegerValue_bigint>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ var "i"),
_IntegerValue_int8>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.int8ToBigint $ var "i"),
_IntegerValue_int16>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.int16ToBigint $ var "i"),
_IntegerValue_int32>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_int $ var "i"),
_IntegerValue_int64>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.int64ToBigint $ var "i"),
_IntegerValue_uint8>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.uint8ToBigint $ var "i"),
_IntegerValue_uint16>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.uint16ToBigint $ var "i"),
_IntegerValue_uint32>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.uint32ToBigint $ var "i"),
_IntegerValue_uint64>>: "i" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_integer $ Literals.uint64ToBigint $ var "i")],
_Literal_string>>: "s" ~>
right $ HaskellUtils.hslit @@ (inject H._Literal H._Literal_string $ var "s")]
encodeTerm :: TTermDefinition (Int -> HaskellNamespaces -> Term -> Context -> Graph -> Either Error H.Expression)
encodeTerm = haskellCoderDefinition "encodeTerm" $
doc "Encode a Hydra term as a Haskell expression" $
"depth" ~> "namespaces" ~> "term" ~> "cx" ~> "g" ~> lets [
"encode">: "t" ~> encodeTerm @@ var "depth" @@ var "namespaces" @@ var "t" @@ var "cx" @@ var "g"] $
"nonemptyMap" <~ ("m" ~> lets [
"lhs">: HaskellUtils.hsvar @@ string "M.fromList",
"encodePair">: "pair" ~> lets [
"k">: Pairs.first $ var "pair",
"v">: Pairs.second $ var "pair"] $
"hk" <<~ var "encode" @@ var "k" $
"hv" <<~ var "encode" @@ var "v" $
right $ inject H._Expression H._Expression_tuple $ list [var "hk", var "hv"]] $
"rhs" <<~ Eithers.map
(unaryFunction $ inject H._Expression H._Expression_list)
(Eithers.mapList (var "encodePair") $ Maps.toList (var "m")) $
right $ HaskellUtils.hsapp @@ var "lhs" @@ var "rhs") $
"nonemptySet" <~ ("s" ~> lets [
"lhs">: HaskellUtils.hsvar @@ string "S.fromList" ] $
"rhs" <<~ encodeTerm @@ var "depth" @@ var "namespaces" @@ (inject _Term _Term_list $ Sets.toList $ var "s") @@ var "cx" @@ var "g" $
right $ HaskellUtils.hsapp @@ var "lhs" @@ var "rhs") $
cases _Term (Strip.deannotateTerm @@ var "term")
(Just $ Ctx.failInContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "supported term") (ShowCore.term @@ var "term")) (var "cx")) [
_Term_application>>: "app" ~> lets [
"fun">: Core.applicationFunction $ var "app",
"arg">: Core.applicationArgument $ var "app",
"deannotatedFun">: Strip.deannotateTerm @@ (var "fun")] $
-- When the function is a union elimination, encode as a direct case expression
-- instead of (\x -> case x of ...) arg
cases _Term (var "deannotatedFun")
(Just $
"hfun" <<~ var "encode" @@ var "fun" $
"harg" <<~ var "encode" @@ var "arg" $
right $ HaskellUtils.hsapp @@ var "hfun" @@ var "harg") [
_Term_cases>>: "stmt" ~>
"harg" <<~ var "encode" @@ var "arg" $
encodeCaseExpression @@ var "depth" @@ var "namespaces" @@ var "stmt" @@ var "harg" @@ var "cx" @@ var "g"],
_Term_cases>>: "stmt" ~>
encodeStandaloneCases @@ var "depth" @@ var "namespaces" @@ var "stmt" @@ var "cx" @@ var "g",
_Term_either>>: "e" ~> Eithers.either_
("l" ~>
"hl" <<~ var "encode" @@ var "l" $
right $ HaskellUtils.hsapp @@ (HaskellUtils.hsvar @@ string "Left") @@ var "hl")
("r" ~>
"hr" <<~ var "encode" @@ var "r" $
right $ HaskellUtils.hsapp @@ (HaskellUtils.hsvar @@ string "Right") @@ var "hr")
(var "e"),
_Term_lambda>>: "lam" ~>
encodeLambdaTerm @@ var "depth" @@ var "namespaces" @@ var "lam" @@ var "cx" @@ var "g",
_Term_project>>: "proj" ~>
encodeProjection @@ var "namespaces" @@ var "proj",
_Term_unwrap>>: "name" ~>
encodeUnwrap @@ var "namespaces" @@ var "name",
_Term_let>>: "letTerm" ~> lets [
"collectBindings">: "lt" ~>
"bs" <~ Core.letBindings (var "lt") $
"body" <~ Core.letBody (var "lt") $
cases _Term (Strip.deannotateTerm @@ var "body")
(Just $ pair (var "bs") (var "body")) [
_Term_let>>: "innerLt" ~>
"innerResult" <~ var "collectBindings" @@ var "innerLt" $
pair (Lists.concat2 (var "bs") (Pairs.first $ var "innerResult")) (Pairs.second $ var "innerResult")],
"collected">: var "collectBindings" @@ var "letTerm",
"allBindings">: Pairs.first $ var "collected",
"finalBody">: Pairs.second $ var "collected",
"encodeBinding">: "binding" ~> lets [
"name">: Core.bindingName $ var "binding",
"term'">: Core.bindingTerm $ var "binding",
"hname">: HaskellUtils.simpleName @@ (Core.unName $ var "name")] $
"hexpr" <<~ var "encode" @@ var "term'" $
right $ inject H._LocalBinding H._LocalBinding_value $ HaskellUtils.simpleValueBinding @@ var "hname" @@ var "hexpr" @@ nothing] $
"hbindings" <<~ Eithers.mapList (var "encodeBinding") (var "allBindings") $
"hinner" <<~ var "encode" @@ var "finalBody" $
right $ inject H._Expression H._Expression_let $ record H._LetExpression [
H._LetExpression_bindings>>: var "hbindings",
H._LetExpression_inner>>: var "hinner"],
_Term_list>>: "els" ~>
"helems" <<~ Eithers.mapList (var "encode") (var "els") $
right $ inject H._Expression H._Expression_list $ var "helems",
_Term_literal>>: "v" ~>
encodeLiteral @@ var "v" @@ var "cx",
_Term_map>>: "m" ~> Logic.ifElse (Maps.null $ var "m")
(right $ HaskellUtils.hsvar @@ string "M.empty")
(var "nonemptyMap" @@ var "m"),
_Term_maybe>>: "m" ~>
Maybes.cases (var "m")
(right $ HaskellUtils.hsvar @@ string "Nothing") $
"t" ~>
"ht" <<~ var "encode" @@ var "t" $
right $ HaskellUtils.hsapp @@ (HaskellUtils.hsvar @@ string "Just") @@ var "ht",
_Term_pair>>: "p" ~>
"f" <<~ var "encode" @@ Pairs.first (var "p") $
"s" <<~ var "encode" @@ Pairs.second (var "p") $
right $ inject H._Expression H._Expression_tuple $ list [var "f", var "s"],
_Term_record>>: "record" ~> lets [
"sname">: Core.recordTypeName $ var "record",
"fields">: Core.recordFields $ var "record",
"toFieldUpdate">: "field" ~> lets [
"fn">: Core.fieldName $ var "field",
"ft">: Core.fieldTerm $ var "field",
"fieldRef">: HaskellUtils.recordFieldReference @@ var "namespaces" @@ var "sname" @@ var "fn"] $
"hft" <<~ var "encode" @@ var "ft" $
right $ record H._FieldUpdate [
H._FieldUpdate_name>>: var "fieldRef",
H._FieldUpdate_value>>: var "hft"],
"typeName">: HaskellUtils.elementReference @@ var "namespaces" @@ var "sname"] $
"updates" <<~ Eithers.mapList (var "toFieldUpdate") (var "fields") $
right $ inject H._Expression H._Expression_constructRecord $ record H._ConstructRecordExpression [
H._ConstructRecordExpression_name>>: var "typeName",
H._ConstructRecordExpression_fields>>: var "updates"],
_Term_set>>: "s" ~> Logic.ifElse (Sets.null $ var "s")
(right $ HaskellUtils.hsvar @@ string "S.empty")
(var "nonemptySet" @@ var "s"),
_Term_typeLambda>>: "abs" ~> lets [
"term1">: Core.typeLambdaBody $ var "abs"] $
var "encode" @@ var "term1",
_Term_typeApplication>>: "typed" ~> lets [
"term1">: Core.typeApplicationTermBody $ var "typed"] $
var "encode" @@ var "term1",
_Term_inject>>: "injection" ~> lets [
"sname">: Core.injectionTypeName $ var "injection",
"field">: Core.injectionField $ var "injection",
"fn">: Core.fieldName $ var "field",
"ft">: Core.fieldTerm $ var "field",
"lhs">: inject H._Expression H._Expression_variable $ HaskellUtils.unionFieldReference @@ (Sets.union (Sets.fromList (Maps.keys (Graph.graphBoundTerms $ var "g"))) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes $ var "g")))) @@ var "namespaces" @@ var "sname" @@ var "fn",
"dflt">: Eithers.map (HaskellUtils.hsapp @@ var "lhs") (var "encode" @@ var "ft")] $
"ftyp" <<~ Resolution.requireUnionField_ @@ var "cx" @@ var "g" @@ var "sname" @@ var "fn" $
cases _Type (Strip.deannotateType @@ var "ftyp")
(Just $ var "dflt") [
_Type_unit>>: constant $ right $ var "lhs"],
_Term_unit>>: constant $ right $ inject H._Expression H._Expression_tuple $ list ([] :: [TTerm H.Expression]),
_Term_variable>>: "name" ~>
right $ inject H._Expression H._Expression_variable $ HaskellUtils.elementReference @@ var "namespaces" @@ var "name",
_Term_wrap>>: "wrapped" ~> lets [
"tname">: Core.wrappedTermTypeName $ var "wrapped",
"term'">: Core.wrappedTermBody $ var "wrapped",
"lhs">: inject H._Expression H._Expression_variable $ HaskellUtils.elementReference @@ var "namespaces" @@ var "tname"] $
"rhs" <<~ var "encode" @@ var "term'" $
right $ HaskellUtils.hsapp @@ var "lhs" @@ var "rhs"]
encodeType :: TTermDefinition (HaskellNamespaces -> Type -> Context -> Graph -> Either Error H.Type)
encodeType = haskellCoderDefinition "encodeType" $
doc "Encode a Hydra type as a Haskell type" $
"namespaces" ~>
"typ" ~> "cx" ~> "g" ~> lets [
"encode">: "t" ~> encodeType @@ var "namespaces" @@ var "t" @@ var "cx" @@ var "g",
"ref">: "name" ~>
right $ inject H._Type H._Type_variable $ HaskellUtils.elementReference @@ var "namespaces" @@ var "name",
"unitTuple">: inject H._Type H._Type_tuple $ list ([] :: [TTerm H.Type])] $
cases _Type (Strip.deannotateType @@ var "typ")
(Just $ Ctx.failInContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "supported type") (ShowCore.type_ @@ var "typ")) (var "cx")) [
_Type_application>>: "app" ~> lets [
"lhs">: Core.applicationTypeFunction $ var "app",
"rhs">: Core.applicationTypeArgument $ var "app"] $
"hlhs" <<~ var "encode" @@ var "lhs" $
"hrhs" <<~ var "encode" @@ var "rhs" $
right $ HaskellUtils.toTypeApplication @@ list [var "hlhs", var "hrhs"],
_Type_either>>: "eitherType" ~> lets [
"left'">: Core.eitherTypeLeft $ var "eitherType",
"right'">: Core.eitherTypeRight $ var "eitherType"] $
"hleft" <<~ var "encode" @@ var "left'" $
"hright" <<~ var "encode" @@ var "right'" $
right $ HaskellUtils.toTypeApplication @@ list [
inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Either",
var "hleft",
var "hright"],
_Type_function>>: "funType" ~> lets [
"dom">: Core.functionTypeDomain $ var "funType",
"cod">: Core.functionTypeCodomain $ var "funType"] $
"hdom" <<~ var "encode" @@ var "dom" $
"hcod" <<~ var "encode" @@ var "cod" $
right $ inject H._Type H._Type_function $ record H._FunctionType [
H._FunctionType_domain>>: var "hdom",
H._FunctionType_codomain>>: var "hcod"],
_Type_forall>>: "forallType" ~> lets [
"v">: Core.forallTypeParameter $ var "forallType",
"body">: Core.forallTypeBody $ var "forallType"] $
var "encode" @@ var "body",
_Type_list>>: "lt" ~>
"hlt" <<~ var "encode" @@ var "lt" $
right $ inject H._Type H._Type_list $ var "hlt",
_Type_literal>>: "lt" ~>
cases _LiteralType (var "lt")
(Just $ Ctx.failInContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "supported literal type") (ShowCore.literalType @@ var "lt")) (var "cx")) [
_LiteralType_binary>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "B.ByteString",
_LiteralType_boolean>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Bool",
_LiteralType_decimal>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Sci.Scientific",
_LiteralType_float>>: "ft" ~>
cases _FloatType (var "ft") Nothing [
_FloatType_float32>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Float",
_FloatType_float64>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Double",
_FloatType_bigfloat>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Double"],
_LiteralType_integer>>: "it" ~>
cases _IntegerType (var "it")
(Just $ Ctx.failInContext (Error.errorExtraction $ Error.extractionErrorUnexpectedShape $ Error.unexpectedShapeError (string "supported integer type") (ShowCore.integerType @@ var "it")) (var "cx")) [
_IntegerType_bigint>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Integer",
_IntegerType_int8>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "I.Int8",
_IntegerType_int16>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "I.Int16",
_IntegerType_int32>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Int",
_IntegerType_int64>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "I.Int64"],
_LiteralType_string>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "String"],
_Type_map>>: "mapType" ~> lets [
"kt">: Core.mapTypeKeys $ var "mapType",
"vt">: Core.mapTypeValues $ var "mapType"] $
"hkt" <<~ var "encode" @@ var "kt" $
"hvt" <<~ var "encode" @@ var "vt" $
right $ HaskellUtils.toTypeApplication @@ list [
inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "M.Map",
var "hkt",
var "hvt"],
_Type_maybe>>: "ot" ~>
"hot" <<~ var "encode" @@ var "ot" $
right $ HaskellUtils.toTypeApplication @@ list [
inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Maybe",
var "hot"],
_Type_pair>>: "pt" ~>
"f" <<~ var "encode" @@ (Core.pairTypeFirst $ var "pt") $
"s" <<~ var "encode" @@ (Core.pairTypeSecond $ var "pt") $
right $ inject H._Type H._Type_tuple $ list [var "f", var "s"],
_Type_record>>: constant (var "ref" @@ Core.name (string "placeholder")),
_Type_set>>: "st" ~>
"hst" <<~ var "encode" @@ var "st" $
right $ HaskellUtils.toTypeApplication @@ list [
inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "S.Set",
var "hst"],
_Type_union>>: constant (var "ref" @@ Core.name (string "placeholder")),
_Type_unit>>: constant $ right $ var "unitTuple",
_Type_variable>>: "v1" ~> var "ref" @@ var "v1",
_Type_void>>: constant $
right $ inject H._Type H._Type_variable $ HaskellUtils.rawName @@ string "Void",
_Type_wrap>>: constant (var "ref" @@ Core.name (string "placeholder"))]
encodeTypeWithClassAssertions :: TTermDefinition (HaskellNamespaces -> M.Map Name (S.Set TypeClass) -> Type -> Context -> Graph -> Either Error H.Type)
encodeTypeWithClassAssertions = haskellCoderDefinition "encodeTypeWithClassAssertions" $
doc "Encode a Hydra type as a Haskell type with typeclass assertions" $
"namespaces" ~> "explicitClasses" ~> "typ" ~> "cx" ~> "g" ~> lets [
"classes">: Maps.union (var "explicitClasses") (getImplicitTypeClasses @@ var "typ"),
"implicitClasses">: getImplicitTypeClasses @@ var "typ",
"encodeAssertion">: "pair" ~> lets [
"name">: Pairs.first $ var "pair",
"cls">: Pairs.second $ var "pair",
"hname">: HaskellUtils.rawName @@ cases _TypeClass (var "cls") Nothing [
_TypeClass_equality>>: constant $ string "Eq",
_TypeClass_ordering>>: constant $ string "Ord"],
"htype">: inject H._Type H._Type_variable $ HaskellUtils.rawName @@ (Core.unName $ var "name")] $
inject H._Assertion H._Assertion_class $ record H._ClassAssertion [
H._ClassAssertion_name>>: var "hname",
H._ClassAssertion_types>>: list [var "htype"]],
"assertPairs">: Lists.concat $ Lists.map (var "toPairs") (Maps.toList $ var "classes"),
"toPairs">: "mapEntry" ~> lets [
"name">: Pairs.first $ var "mapEntry",
"clsSet">: Pairs.second $ var "mapEntry",
"toPair">: "c" ~>
pair (var "name") (var "c")] $
Lists.map (var "toPair") (Sets.toList $ var "clsSet")] $
"htyp" <<~ adaptTypeToHaskellAndEncode @@ var "namespaces" @@ var "typ" @@ var "cx" @@ var "g" $
Logic.ifElse (Lists.null $ var "assertPairs")
(right $ var "htyp") (lets [
"encoded">: Lists.map (var "encodeAssertion") (var "assertPairs"),
"hassert">: Logic.ifElse (Equality.equal (Lists.length $ var "encoded") (int32 1))
(Maybes.fromMaybe (inject H._Assertion H._Assertion_tuple $ var "encoded") (Lists.maybeHead $ var "encoded"))
(inject H._Assertion H._Assertion_tuple $ var "encoded")] $
right $ inject H._Type H._Type_ctx $ record H._ContextType [
H._ContextType_ctx>>: var "hassert",
H._ContextType_type>>: var "htyp"])
extendMetaForTerm :: TTermDefinition (HE.HaskellModuleMetadata -> Term -> HE.HaskellModuleMetadata)
extendMetaForTerm = haskellCoderDefinition "extendMetaForTerm" $
doc "Extend metadata by analyzing a term for standard import usage (bottom-up step function)" $
"meta" ~> "term" ~>
cases _Term (var "term") (Just $ var "meta") [
_Term_map>>: constant $
setMetaUsesMap @@ true @@ var "meta",
_Term_set>>: constant $
setMetaUsesSet @@ true @@ var "meta"]
extendMetaForType :: TTermDefinition (HE.HaskellModuleMetadata -> Type -> HE.HaskellModuleMetadata)
extendMetaForType = haskellCoderDefinition "extendMetaForType" $
doc "Extend metadata by analyzing a type for standard import usage (bottom-up step function)" $
"meta" ~> "typ" ~>
cases _Type (Strip.deannotateType @@ var "typ") (Just $ var "meta") [
_Type_literal>>: "lt" ~>
cases _LiteralType (var "lt") (Just $ var "meta") [
_LiteralType_binary>>: constant $
setMetaUsesByteString @@ true @@ var "meta",
_LiteralType_integer>>: "it" ~>
cases _IntegerType (var "it") (Just $ var "meta") [
_IntegerType_int8>>: constant $ setMetaUsesInt @@ true @@ var "meta",
_IntegerType_int16>>: constant $ setMetaUsesInt @@ true @@ var "meta",
_IntegerType_int64>>: constant $ setMetaUsesInt @@ true @@ var "meta"]],
_Type_map>>: constant $
setMetaUsesMap @@ true @@ var "meta",
_Type_set>>: constant $
setMetaUsesSet @@ true @@ var "meta"]
findOrdVariables :: TTermDefinition (Type -> S.Set Name)
findOrdVariables = haskellCoderDefinition "findOrdVariables" $
doc "Find type variables that require an Ord constraint (used in maps or sets)" $
"typ" ~> lets [
"fold">: "names" ~> "typ'" ~>
cases _Type (var "typ'")
(Just $ var "names") [
_Type_map>>: "mapType" ~> lets [
"kt">: Core.mapTypeKeys $ var "mapType"] $
var "tryType" @@ var "names" @@ var "kt",
_Type_set>>: "et" ~>
var "tryType" @@ var "names" @@ var "et"],
"isTypeVariable">: "v" ~>
Maybes.isNothing $ Names.namespaceOf @@ var "v",
"tryType">: "names" ~> "t" ~>
cases _Type (Strip.deannotateType @@ var "t")
(Just $ var "names") [
_Type_variable>>: "v" ~>
Logic.ifElse (var "isTypeVariable" @@ var "v")
(Sets.insert (var "v") (var "names"))
(var "names")]] $
Rewriting.foldOverType @@ Coders.traversalOrderPre @@ var "fold" @@ Sets.empty @@ var "typ"
gatherMetadata :: TTermDefinition ([Definition] -> HE.HaskellModuleMetadata)
gatherMetadata = haskellCoderDefinition "gatherMetadata" $
doc "Gather metadata from definitions by bottom-up traversal of all terms and types" $
"defs" ~>
"addDef" <~ ("meta" ~> "def" ~>
cases _Definition (var "def") Nothing [
_Definition_term>>: "termDef" ~>
"term" <~ Packaging.termDefinitionTerm (var "termDef") $
"metaWithTerm" <~ (Rewriting.foldOverTerm @@ Coders.traversalOrderPre
@@ ("m" ~> "t" ~> extendMetaForTerm @@ var "m" @@ var "t") @@ var "meta" @@ var "term") $
Maybes.maybe (var "metaWithTerm")
("ts" ~>
Rewriting.foldOverType @@ Coders.traversalOrderPre
@@ ("m" ~> "t" ~> extendMetaForType @@ var "m" @@ var "t") @@ var "metaWithTerm" @@ (Core.typeSchemeBody $ var "ts"))
(Packaging.termDefinitionTypeScheme $ var "termDef"),
_Definition_type>>: "typeDef" ~>
"typ" <~ (Core.typeSchemeBody $ Packaging.typeDefinitionTypeScheme (var "typeDef")) $
Rewriting.foldOverType @@ Coders.traversalOrderPre
@@ ("m" ~> "t" ~> extendMetaForType @@ var "m" @@ var "t") @@ var "meta" @@ var "typ"]) $
Lists.foldl (var "addDef") (asTerm emptyMetadata) (var "defs")
getImplicitTypeClasses :: TTermDefinition (Type -> M.Map Name (S.Set TypeClass))
getImplicitTypeClasses = haskellCoderDefinition "getImplicitTypeClasses" $
doc "Get implicit typeclass constraints for type variables that need Ord" $
"typ" ~> lets [
"toPair">: "name" ~>
pair (var "name") (Sets.fromList $ list [Graph.typeClassOrdering])] $
Maps.fromList $ Lists.map (var "toPair") (Sets.toList $ findOrdVariables @@ var "typ")
moduleToHaskellModule :: TTermDefinition (Module -> [Definition] -> Context -> Graph -> Prelude.Either Error H.Module)
moduleToHaskellModule = haskellCoderDefinition "moduleToHaskellModule" $
doc "Convert a Hydra module and definitions to a Haskell module AST" $
"mod" ~> "defs" ~> "cx" ~> "g" ~>
"namespaces" <<~ HaskellUtils.namespacesForModule @@ var "mod" @@ var "cx" @@ var "g" $
constructModule @@ var "namespaces" @@ var "mod" @@ var "defs" @@ var "cx" @@ var "g"
moduleToHaskell :: TTermDefinition (Module -> [Definition] -> Context -> Graph -> Prelude.Either Error (M.Map String String))
moduleToHaskell = haskellCoderDefinition "moduleToHaskell" $
doc "Convert a Hydra module to Haskell source code as a filepath-to-content map" $
"mod" ~> "defs" ~> "cx" ~> "g" ~>
"hsmod" <<~ moduleToHaskellModule @@ var "mod" @@ var "defs" @@ var "cx" @@ var "g" $ lets [
"s">: Serialization.printExpr @@ (Serialization.parenthesize @@ (HaskellSerde.moduleToExpr @@ var "hsmod")),
"filepath">: Names.namespaceToFilePath @@ Util.caseConventionPascal @@ (wrap _FileExtension $ string "hs") @@ (Packaging.moduleNamespace $ var "mod")] $
right $ Maps.singleton (var "filepath") (var "s")
nameDecls :: TTermDefinition (HaskellNamespaces -> Name -> Type -> [H.DeclarationWithComments])
nameDecls = haskellCoderDefinition "nameDecls" $
doc "Generate Haskell declarations for type and field name constants" $
"namespaces" ~> "name" ~> "typ" ~> lets [
"nm">: Core.unName $ var "name",
"toDecl">: "n" ~> "pair" ~> lets [
"k">: Pairs.first $ var "pair",
"v">: Pairs.second $ var "pair",
"decl">: inject H._Declaration H._Declaration_valueBinding $ inject H._ValueBinding H._ValueBinding_simple $ record H._SimpleValueBinding [
H._SimpleValueBinding_pattern>>: HaskellUtils.applicationPattern @@ (HaskellUtils.simpleName @@ var "k") @@ list ([] :: [TTerm H.Pattern]),
H._SimpleValueBinding_rhs>>: wrap H._RightHandSide $ inject H._Expression H._Expression_application $ record H._ApplicationExpression [
H._ApplicationExpression_function>>: inject H._Expression H._Expression_variable $ HaskellUtils.elementReference @@ var "namespaces" @@ var "n",
H._ApplicationExpression_argument>>: inject H._Expression H._Expression_literal $ inject H._Literal H._Literal_string $ var "v"],
H._SimpleValueBinding_localBindings>>: nothing]] $
record H._DeclarationWithComments [
H._DeclarationWithComments_body>>: var "decl",
H._DeclarationWithComments_comments>>: nothing],
"nameDecl">: pair (constantForTypeName @@ var "name") (var "nm"),
"fieldDecls">: Lists.map (var "toConstant") (Lexical.fieldsOf @@ var "typ"),
"toConstant">: "fieldType" ~> lets [
"fname">: Core.fieldTypeName $ var "fieldType"] $
pair (constantForFieldName @@ var "name" @@ var "fname") (Core.unName $ var "fname")] $
Logic.ifElse (useCoreImport)
(Lists.cons (var "toDecl" @@ Core.nameLift _Name @@ var "nameDecl") (Lists.map (var "toDecl" @@ Core.nameLift _Name) (var "fieldDecls")))
(list ([] :: [TTerm H.DeclarationWithComments]))
setMetaUsesByteString :: TTermDefinition (Bool -> HE.HaskellModuleMetadata -> HE.HaskellModuleMetadata)
setMetaUsesByteString = haskellCoderDefinition "setMetaUsesByteString" $
"b" ~> "m" ~>
record HE._HaskellModuleMetadata [
HE._HaskellModuleMetadata_usesByteString>>: var "b",
HE._HaskellModuleMetadata_usesInt>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesInt @@ var "m",
HE._HaskellModuleMetadata_usesMap>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesMap @@ var "m",
HE._HaskellModuleMetadata_usesSet>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesSet @@ var "m"]
setMetaUsesInt :: TTermDefinition (Bool -> HE.HaskellModuleMetadata -> HE.HaskellModuleMetadata)
setMetaUsesInt = haskellCoderDefinition "setMetaUsesInt" $
"b" ~> "m" ~>
record HE._HaskellModuleMetadata [
HE._HaskellModuleMetadata_usesByteString>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesByteString @@ var "m",
HE._HaskellModuleMetadata_usesInt>>: var "b",
HE._HaskellModuleMetadata_usesMap>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesMap @@ var "m",
HE._HaskellModuleMetadata_usesSet>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesSet @@ var "m"]
setMetaUsesMap :: TTermDefinition (Bool -> HE.HaskellModuleMetadata -> HE.HaskellModuleMetadata)
setMetaUsesMap = haskellCoderDefinition "setMetaUsesMap" $
"b" ~> "m" ~>
record HE._HaskellModuleMetadata [
HE._HaskellModuleMetadata_usesByteString>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesByteString @@ var "m",
HE._HaskellModuleMetadata_usesInt>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesInt @@ var "m",
HE._HaskellModuleMetadata_usesMap>>: var "b",
HE._HaskellModuleMetadata_usesSet>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesSet @@ var "m"]
setMetaUsesSet :: TTermDefinition (Bool -> HE.HaskellModuleMetadata -> HE.HaskellModuleMetadata)
setMetaUsesSet = haskellCoderDefinition "setMetaUsesSet" $
"b" ~> "m" ~>
record HE._HaskellModuleMetadata [
HE._HaskellModuleMetadata_usesByteString>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesByteString @@ var "m",
HE._HaskellModuleMetadata_usesInt>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesInt @@ var "m",
HE._HaskellModuleMetadata_usesMap>>:
project HE._HaskellModuleMetadata HE._HaskellModuleMetadata_usesMap @@ var "m",
HE._HaskellModuleMetadata_usesSet>>: var "b"]
toDataDeclaration :: TTermDefinition (HaskellNamespaces -> TermDefinition -> Context -> Graph -> Either Error H.DeclarationWithComments)
toDataDeclaration = haskellCoderDefinition "toDataDeclaration" $
doc "Convert a Hydra term definition to a Haskell declaration with comments" $
"namespaces" ~> "def" ~> "cx" ~> "g" ~> lets [
"name">: Packaging.termDefinitionName $ var "def",
"term">: Packaging.termDefinitionTerm $ var "def",
"typ">: Packaging.termDefinitionTypeScheme $ var "def",
"hname">: HaskellUtils.simpleName @@ (Names.localNameOf @@ var "name"),
"rewriteValueBinding">: "vb" ~>
cases H._ValueBinding (var "vb") Nothing [
H._ValueBinding_simple>>: "simple" ~> lets [
"pattern'">: project H._SimpleValueBinding H._SimpleValueBinding_pattern @@ var "simple",
"rhs">: project H._SimpleValueBinding H._SimpleValueBinding_rhs @@ var "simple",
"bindings">: project H._SimpleValueBinding H._SimpleValueBinding_localBindings @@ var "simple"] $
cases H._Pattern (var "pattern'")
(Just $ var "vb") [
H._Pattern_application>>: "appPat" ~> lets [
"name'">: project H._ApplicationPattern H._ApplicationPattern_name @@ var "appPat",
"args">: project H._ApplicationPattern H._ApplicationPattern_args @@ var "appPat",
"rhsExpr">: unwrap H._RightHandSide @@ var "rhs"] $
cases H._Expression (var "rhsExpr")
(Just $ var "vb") [
H._Expression_lambda>>: "lambda'" ~> lets [
"vars">: project H._LambdaExpression H._LambdaExpression_bindings @@ var "lambda'",
"body">: project H._LambdaExpression H._LambdaExpression_inner @@ var "lambda'",
"newPattern">: HaskellUtils.applicationPattern @@ var "name'" @@ (Lists.concat2 (var "args") (var "vars")),
"newRhs">: wrap H._RightHandSide $ var "body"] $
var "rewriteValueBinding" @@ (inject H._ValueBinding H._ValueBinding_simple $ record H._SimpleValueBinding [
H._SimpleValueBinding_pattern>>: var "newPattern",
H._SimpleValueBinding_rhs>>: var "newRhs",
H._SimpleValueBinding_localBindings>>: var "bindings"])]]],
"toDecl">: "comments" ~> "hname'" ~> "term'" ~> "bindings" ~>
cases _Term (Strip.deannotateTerm @@ var "term'")
(Just $
"hterm" <<~ encodeTerm @@ int32 0 @@ var "namespaces" @@ var "term'" @@ var "cx" @@ var "g" $ lets [
"vb">: HaskellUtils.simpleValueBinding @@ var "hname'" @@ var "hterm" @@ var "bindings",
-- Extract constraints from the TypeScheme and convert to class assertions
"schemeConstraints">: optCases (var "typ") Phantoms.nothing ("ts" ~> Core.typeSchemeConstraints (var "ts")),
"schemeClasses">: typeSchemeConstraintsToClassMap @@ var "schemeConstraints"] $
"explicitClasses" <<~ Annotations.getTypeClasses @@ var "cx" @@ var "g" @@ (Strip.removeTypesFromTerm @@ var "term") $
-- Combine constraints from TypeScheme with any explicit annotations
"combinedClasses" <~ Maps.union (var "schemeClasses") (var "explicitClasses") $
"schemeType" <~ optCases (var "typ") Core.typeUnit ("ts" ~> Core.typeSchemeBody (var "ts")) $
"htype" <<~ encodeTypeWithClassAssertions @@ var "namespaces" @@ var "combinedClasses" @@ var "schemeType" @@ var "cx" @@ var "g" $ lets [
"decl">: inject H._Declaration H._Declaration_typedBinding $ record H._TypedBinding [
H._TypedBinding_typeSignature>>: record H._TypeSignature [
H._TypeSignature_name>>: var "hname'",
H._TypeSignature_type>>: var "htype"],
H._TypedBinding_valueBinding>>: var "rewriteValueBinding" @@ var "vb"]] $
right $ record H._DeclarationWithComments [
H._DeclarationWithComments_body>>: var "decl",
H._DeclarationWithComments_comments>>: var "comments"]) [
_Term_let>>: "letTerm" ~> lets [
-- For let terms, encode each binding's term directly
"lbindings">: Core.letBindings $ var "letTerm",
"env">: Core.letBody $ var "letTerm",
"toTermDefinition">: "hname''" ~> "hterm'" ~>
inject H._LocalBinding H._LocalBinding_value $ HaskellUtils.simpleValueBinding @@ var "hname''" @@ var "hterm'" @@ nothing,
"hnames">: Lists.map ("binding" ~> HaskellUtils.simpleName @@ (Core.unName $ Core.bindingName $ var "binding")) (var "lbindings"),
"terms">: Lists.map (unaryFunction $ Core.bindingTerm) (var "lbindings")] $
"hterms" <<~ Eithers.mapList ("t" ~> encodeTerm @@ int32 0 @@ var "namespaces" @@ var "t" @@ var "cx" @@ var "g") (var "terms") $ lets [
"hbindings">: Lists.zipWith (var "toTermDefinition") (var "hnames") (var "hterms"),
-- Merge new bindings with any previously accumulated bindings from outer lets
"prevBindings">: Maybes.maybe (list ([] :: [TTerm H.LocalBinding])) ("lb" ~> unwrap H._LocalBindings @@ var "lb") (var "bindings"),
"allBindings">: Lists.concat2 (var "prevBindings") (var "hbindings")] $
var "toDecl" @@ var "comments" @@ var "hname'" @@ var "env" @@ (just $ wrap H._LocalBindings $ var "allBindings")]] $
"comments" <<~ Annotations.getTermDescription @@ var "cx" @@ var "g" @@ var "term" $
var "toDecl" @@ var "comments" @@ var "hname" @@ var "term" @@ nothing
-- | Simplified version of toTypeDeclarations that works with Name and Type directly
-- This is used with the new Definition-based API
toTypeDeclarationsFrom :: TTermDefinition (HaskellNamespaces -> Name -> Type -> Context -> Graph -> Either Error [H.DeclarationWithComments])
toTypeDeclarationsFrom = haskellCoderDefinition "toTypeDeclarationsFrom" $
doc "Convert a Hydra type definition to Haskell declarations" $
"namespaces" ~> "elementName" ~> "typ" ~> "cx" ~> "g" ~> lets [
"lname">: Names.localNameOf @@ var "elementName",
"hname">: HaskellUtils.simpleName @@ var "lname",
"declHead">: "name" ~> "vars'" ~>
Maybes.fromMaybe
(inject H._DeclarationHead H._DeclarationHead_simple $ var "name")
(Maybes.map
("p" ~> lets [
"h">: Pairs.first $ var "p",
"rest">: Pairs.second $ var "p",
"hvar">: wrap H._Variable $ HaskellUtils.simpleName @@ (Core.unName $ var "h")] $
inject H._DeclarationHead H._DeclarationHead_application $ record H._ApplicationDeclarationHead [
H._ApplicationDeclarationHead_function>>: var "declHead" @@ var "name" @@ var "rest",
H._ApplicationDeclarationHead_operand>>: var "hvar"])
(Lists.uncons $ var "vars'")),
"newtypeCons">: "tname" ~> "typ'" ~> lets [
"hname0">: HaskellUtils.simpleName @@ (HaskellUtils.newtypeAccessorName @@ var "tname")] $
"htype" <<~ adaptTypeToHaskellAndEncode @@ var "namespaces" @@ var "typ'" @@ var "cx" @@ var "g" $ lets [
"hfield">: record H._FieldWithComments [
H._FieldWithComments_field>>: record H._Field [
H._Field_name>>: var "hname0",
H._Field_type>>: var "htype"],
H._FieldWithComments_comments>>: nothing],
"constructorName">: HaskellUtils.simpleName @@ (Names.localNameOf @@ var "tname")] $
right $ record H._ConstructorWithComments [
H._ConstructorWithComments_body>>: inject H._Constructor H._Constructor_record $ record H._RecordConstructor [
H._RecordConstructor_name>>: var "constructorName",
H._RecordConstructor_fields>>: list [var "hfield"]],
H._ConstructorWithComments_comments>>: nothing],
"recordCons">: "lname'" ~> "fields" ~> lets [
"toField">: "fieldType" ~> lets [
"fname">: Core.fieldTypeName $ var "fieldType",
"ftype">: Core.fieldTypeType $ var "fieldType",
"hname'">: HaskellUtils.simpleName @@ Strings.cat2
(Formatting.decapitalize @@ var "lname'")
(Formatting.capitalize @@ (Core.unName $ var "fname"))] $
"htype" <<~ adaptTypeToHaskellAndEncode @@ var "namespaces" @@ var "ftype" @@ var "cx" @@ var "g" $
"comments" <<~ Annotations.getTypeDescription @@ var "cx" @@ var "g" @@ var "ftype" $
right $ record H._FieldWithComments [
H._FieldWithComments_field>>: record H._Field [
H._Field_name>>: var "hname'",
H._Field_type>>: var "htype"],
H._FieldWithComments_comments>>: var "comments"]] $
"hFields" <<~ Eithers.mapList (var "toField") (var "fields") $
right $ record H._ConstructorWithComments [
H._ConstructorWithComments_body>>: inject H._Constructor H._Constructor_record $ record H._RecordConstructor [
H._RecordConstructor_name>>: HaskellUtils.simpleName @@ var "lname'",
H._RecordConstructor_fields>>: var "hFields"],
H._ConstructorWithComments_comments>>: nothing],
"unionCons">: "boundNames'" ~> "lname'" ~> "fieldType" ~> lets [
"fname">: Core.fieldTypeName $ var "fieldType",
"ftype">: Core.fieldTypeType $ var "fieldType",
"deconflict">: "name" ~> lets [
"tname">: Names.unqualifyName @@ record _QualifiedName [
_QualifiedName_namespace>>: just $ Pairs.first $ Packaging.namespacesFocus $ var "namespaces",
_QualifiedName_local>>: var "name"]] $
Logic.ifElse (Sets.member (var "tname") (var "boundNames'"))
(var "deconflict" @@ Strings.cat2 (var "name") (string "_"))
(var "name")] $
"comments" <<~ Annotations.getTypeDescription @@ var "cx" @@ var "g" @@ var "ftype" $ lets [
"nm">: var "deconflict" @@ Strings.cat2 (Formatting.capitalize @@ var "lname'") (Formatting.capitalize @@ (Core.unName $ var "fname"))] $
"typeList" <<~ (Logic.ifElse (Equality.equal (Strip.deannotateType @@ var "ftype") MetaTypes.unit)
(right $ list ([] :: [TTerm H.CaseRhs])) $
"htype" <<~ adaptTypeToHaskellAndEncode @@ var "namespaces" @@ var "ftype" @@ var "cx" @@ var "g" $
right $ list [var "htype"]) $
right $ record H._ConstructorWithComments [
H._ConstructorWithComments_body>>: inject H._Constructor H._Constructor_ordinary $ record H._OrdinaryConstructor [
H._OrdinaryConstructor_name>>: HaskellUtils.simpleName @@ var "nm",
H._OrdinaryConstructor_fields>>: var "typeList"],
H._ConstructorWithComments_comments>>: var "comments"]] $
"isSer" <<~ Predicates.isSerializableByName @@ var "cx" @@ var "g" @@ var "elementName" $ lets [
"deriv">: wrap H._Deriving $ Logic.ifElse (var "isSer")
(Lists.map (HaskellUtils.rawName) (list [string "Eq", string "Ord", string "Read", string "Show"]))
(list ([] :: [TTerm H.Name])),
"unpackResult">: HaskellUtils.unpackForallType @@ var "typ",
"vars">: Pairs.first $ var "unpackResult",
"t'">: Pairs.second $ var "unpackResult",
"hd">: var "declHead" @@ var "hname" @@ (Lists.reverse $ var "vars")] $
"decl" <<~ (cases _Type (Strip.deannotateType @@ var "t'")
(Just $ "htype" <<~ (adaptTypeToHaskellAndEncode @@ var "namespaces" @@ var "typ" @@ var "cx" @@ var "g") $
right $ inject H._Declaration H._Declaration_type $ record H._TypeDeclaration [
H._TypeDeclaration_name>>: var "hd",
H._TypeDeclaration_type>>: var "htype"]) [
_Type_record>>: "rt" ~>
"cons" <<~ (var "recordCons" @@ var "lname" @@ var "rt") $
right $ inject H._Declaration H._Declaration_data $ record H._DataDeclaration [
H._DataDeclaration_keyword>>: injectUnit H._DataOrNewtype H._DataOrNewtype_data,
H._DataDeclaration_context>>: list ([] :: [TTerm H.Assertion]),
H._DataDeclaration_head>>: var "hd",
H._DataDeclaration_constructors>>: list [var "cons"],
H._DataDeclaration_deriving>>: list [var "deriv"]],
_Type_union>>: "rt" ~>
"cons" <<~ Eithers.mapList (var "unionCons" @@ (Sets.fromList (Maps.keys (Graph.graphBoundTerms $ var "g"))) @@ var "lname") (var "rt") $
right $ inject H._Declaration H._Declaration_data $ record H._DataDeclaration [
H._DataDeclaration_keyword>>: injectUnit H._DataOrNewtype H._DataOrNewtype_data,
H._DataDeclaration_context>>: list ([] :: [TTerm H.Assertion]),
H._DataDeclaration_head>>: var "hd",
H._DataDeclaration_constructors>>: var "cons",
H._DataDeclaration_deriving>>: list [var "deriv"]],
_Type_wrap>>: "wrapped" ~>
"cons" <<~ var "newtypeCons" @@ var "elementName" @@ var "wrapped" $
right $ inject H._Declaration H._Declaration_data $ record H._DataDeclaration [
H._DataDeclaration_keyword>>: injectUnit H._DataOrNewtype H._DataOrNewtype_newtype,
H._DataDeclaration_context>>: list ([] :: [TTerm H.Assertion]),
H._DataDeclaration_head>>: var "hd",
H._DataDeclaration_constructors>>: list [var "cons"],
H._DataDeclaration_deriving>>: list [var "deriv"]]]) $
"comments" <<~ Annotations.getTypeDescription @@ var "cx" @@ var "g" @@ var "typ" $
"tdecls" <<~ (Logic.ifElse (includeTypeDefinitions)
("decl'" <<~ typeDecl @@ var "namespaces" @@ var "elementName" @@ var "typ" @@ var "cx" @@ var "g" $
right $ list [var "decl'"])
(right $ list ([] :: [TTerm H.DeclarationWithComments]))) $ lets [
"mainDecl">: record H._DeclarationWithComments [
H._DeclarationWithComments_body>>: var "decl",
H._DeclarationWithComments_comments>>: var "comments"],
"nameDecls'">: nameDecls @@ var "namespaces" @@ var "elementName" @@ var "typ"] $
right $ Lists.concat $ list [list [var "mainDecl"], var "nameDecls'", var "tdecls"]
typeDecl :: TTermDefinition (HaskellNamespaces -> Name -> Type -> Context -> Graph -> Either Error H.DeclarationWithComments)
typeDecl = haskellCoderDefinition "typeDecl" $
doc "Generate a Haskell declaration for a type definition constant" $
"namespaces" ~> "name" ~> "typ" ~> "cx" ~> "g" ~> lets [
"typeName">: "ns" ~> "name'" ~>
Names.qname @@ var "ns" @@ (var "typeNameLocal" @@ var "name'"),
"typeNameLocal">: "name'" ~>
Strings.cat $ list [string "_", Names.localNameOf @@ var "name'", string "_type_"],
"rawTerm">: encoderFor _Type @@ var "typ",
"rewrite">: "recurse" ~> "term" ~> lets [
"variantResult">: cases _Term (Strip.deannotateTerm @@ var "term")
(Just nothing) [
_Term_inject>>: "inj" ~> Logic.ifElse (Equality.equal (Core.injectionTypeName $ var "inj") (Core.nameLift _Type))
(just $ Core.injectionField $ var "inj")
nothing],
"decodeString">: "term" ~> (cases _Term (Strip.deannotateTerm @@ var "term")
(Just nothing) [
_Term_literal>>: "lit" ~> cases _Literal (var "lit")
(Just nothing) [
_Literal_string>>: "s" ~> just (var "s")]]),
"decodeName">: "term" ~> (cases _Term (Strip.deannotateTerm @@ var "term")
(Just nothing) [
_Term_wrap>>: "wt" ~> Logic.ifElse (Equality.equal (Core.wrappedTermTypeName $ var "wt") (Core.nameLift _Name))
(Maybes.map (unaryFunction Core.name) $ var "decodeString" @@ (Core.wrappedTermBody $ var "wt"))
nothing]),
"forType">: "field" ~> lets [
"fname">: Core.fieldName $ var "field",
"fterm">: Core.fieldTerm $ var "field"] $
Logic.ifElse (Equality.equal (var "fname") $ Core.nameLift _Type_record)
nothing
(Logic.ifElse (Equality.equal (var "fname") $ Core.nameLift _Type_variable)
(Maybes.bind (var "decodeName" @@ var "fterm") (var "forVariableType"))
nothing),
"forVariableType">: "vname" ~> lets [
"qname">: Names.qualifyName @@ var "vname",
"mns">: Packaging.qualifiedNameNamespace $ var "qname",
"local">: Packaging.qualifiedNameLocal $ var "qname"] $
Maybes.map ("ns" ~> Core.termVariable $ Names.qname @@ var "ns" @@ (Strings.cat $ list [string "_", var "local", string "_type_"])) (var "mns")] $
Maybes.fromMaybe (var "recurse" @@ var "term") (Maybes.bind (var "variantResult") (var "forType")),
"finalTerm">: Rewriting.rewriteTerm @@ var "rewrite" @@ var "rawTerm"] $
"expr" <<~ encodeTerm @@ int32 0 @@ var "namespaces" @@ var "finalTerm" @@ var "cx" @@ var "g" $ lets [
"rhs">: wrap H._RightHandSide $ var "expr",
"hname">: HaskellUtils.simpleName @@ (var "typeNameLocal" @@ var "name"),
"pat">: HaskellUtils.applicationPattern @@ var "hname" @@ list ([] :: [TTerm H.Pattern]),
"decl">: inject H._Declaration H._Declaration_valueBinding $ inject H._ValueBinding H._ValueBinding_simple $ record H._SimpleValueBinding [
H._SimpleValueBinding_pattern>>: var "pat",
H._SimpleValueBinding_rhs>>: var "rhs",
H._SimpleValueBinding_localBindings>>: nothing]] $
right $ record H._DeclarationWithComments [
H._DeclarationWithComments_body>>: var "decl",
H._DeclarationWithComments_comments>>: nothing]
-- | Convert TypeScheme constraints to the Map format used by encodeTypeWithClassAssertions.
-- TypeScheme constraints are Maybe (Map Name TypeVariableMetadata), where TypeVariableMetadata
-- has a 'classes' field of type Set Name. We convert this to Map Name (Set TypeClass).
typeSchemeConstraintsToClassMap :: TTermDefinition (Maybe (M.Map Name TypeVariableMetadata) -> M.Map Name (S.Set TypeClass))
typeSchemeConstraintsToClassMap = haskellCoderDefinition "typeSchemeConstraintsToClassMap" $
doc "Convert type scheme constraints to a map of type variables to typeclasses" $
"maybeConstraints" ~> lets [
-- Convert a class name to a TypeClass, returning Nothing for unknown classes
"nameToTypeClass">: "className" ~> lets [
"classNameStr">: Core.unName $ var "className",
"isEq">: Equality.equal (var "classNameStr") (Core.unName $ Core.nameLift _TypeClass_equality),
"isOrd">: Equality.equal (var "classNameStr") (Core.unName $ Core.nameLift _TypeClass_ordering)] $
Logic.ifElse (var "isEq")
(just $ inject _TypeClass _TypeClass_equality unit)
(Logic.ifElse (var "isOrd")
(just $ inject _TypeClass _TypeClass_ordering unit)
nothing)] $
Maybes.maybe
Maps.empty
("constraints" ~>
Maps.map
("meta" ~> Sets.fromList $
Maybes.cat $ Lists.map (var "nameToTypeClass") $ Sets.toList $ Core.typeVariableMetadataClasses (var "meta"))
(var "constraints"))
(var "maybeConstraints")