packages feed

hydra-pg-0.18.1: src/main/haskell/Hydra/Pg/SubtermGraph.hs

-- Note: this is an automatically generated file. Do not edit.

-- | The property-graph encoding of a term graph (hydra.core.subterms.TermGraph): a total, lossless map from the already-built, already-classified term-graph view of a typed graph onto hydra.pg's element model. No bespoke term traversal; this module consumes only the TermGraph interface.

module Hydra.Pg.SubtermGraph where

import qualified Hydra.Core.Ast as Ast
import qualified Hydra.Core.Coders as Coders
import qualified Hydra.Core.Diff as Diff
import qualified Hydra.Core.Docs as Docs
import qualified Hydra.Core.Error.Checking as Checking
import qualified Hydra.Core.Error.File as ErrorFile
import qualified Hydra.Core.Error.Model as ErrorModel
import qualified Hydra.Core.Error.Packaging as ErrorPackaging
import qualified Hydra.Core.Error.System as ErrorSystem
import qualified Hydra.Core.Errors as Errors
import qualified Hydra.Core.File as File
import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Json.Model as JsonModel
import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic
import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps
import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals
import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs
import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings
import qualified Hydra.Core.Markdown as Markdown
import qualified Hydra.Core.Model as CoreModel
import qualified Hydra.Core.Packaging as Packaging
import qualified Hydra.Core.Parsing as Parsing
import qualified Hydra.Core.Paths as Paths
import qualified Hydra.Core.Print.Model as PrintModel
import qualified Hydra.Core.Print.Paths as PrintPaths
import qualified Hydra.Core.Query as Query
import qualified Hydra.Core.Regex as Regex
import qualified Hydra.Core.Relational as Relational
import qualified Hydra.Core.System as System
import qualified Hydra.Core.Tabular as Tabular
import qualified Hydra.Core.Testing as Testing
import qualified Hydra.Core.Time as Time
import qualified Hydra.Core.Topology as Topology
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Core.Typing as Typing
import qualified Hydra.Core.Util as Util
import qualified Hydra.Core.Validation as Validation
import qualified Hydra.Core.Variants as Variants
import qualified Hydra.Pg.Model as PgModel
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M

-- | Encode a term graph as a property graph: a vertex per non-leaf node, an edge per non-primitive variable reference, printed subterm paths as edge labels/ids and property keys
encodeTermGraph :: Paths.TermGraph -> PgModel.Graph CoreModel.Term
encodeTermGraph tg =

      let roots = Paths.termGraphRoots tg
          rootResults =
                  Lists.map (\nt ->
                    let name = Pairs.first nt
                        node = Pairs.second nt
                        emptyPath = Paths.SubtermPath []
                        sub = encodeTermNode name emptyPath node
                        rootVertex =
                                PgModel.Vertex {
                                  PgModel.vertexLabel = (PgModel.VertexLabel (PrintModel.type_ (Paths.termNodeType node))),
                                  PgModel.vertexId = (termNodeIdTerm (Paths.TermNodeId {
                                    Paths.termNodeIdRoot = name,
                                    Paths.termNodeIdPath = emptyPath})),
                                  PgModel.vertexProperties = (Pairs.first sub)}
                    in (Lists.concat2 [
                      rootVertex] (Pairs.first (Pairs.second sub)), (Pairs.second (Pairs.second sub)))) (Maps.toList roots)
          allVertices = Lists.concat (Lists.map Pairs.first rootResults)
          allEdges = Lists.concat (Lists.map Pairs.second rootResults)
      in PgModel.Graph {
        PgModel.graphVertices = (Maps.fromList (Lists.map (\v -> (PgModel.vertexId v, v)) allVertices)),
        PgModel.graphEdges = (Maps.fromList (Lists.map (\e -> (PgModel.edgeId e, e)) allEdges))}

-- | Encode one term-graph node into (this node's own properties, descendant vertices, descendant edges)
encodeTermNode :: CoreModel.Name -> Paths.SubtermPath -> Paths.TermNode -> (M.Map PgModel.PropertyKey CoreModel.Term, ([PgModel.Vertex CoreModel.Term], [PgModel.Edge CoreModel.Term]))
encodeTermNode root path node =

      let nid =
              Paths.TermNodeId {
                Paths.termNodeIdRoot = root,
                Paths.termNodeIdPath = path}
          steps = Paths.unSubtermPath path
          links = Paths.termNodeLinks node
          childPathFor = \step -> Paths.SubtermPath (Lists.concat2 steps [
                step])
          keyFor = \p -> PgModel.PropertyKey (PrintPaths.subtermPath p)
          attrKeyFor =
                  \a -> PgModel.PropertyKey (Strings.concat [
                    PrintPaths.subtermPath path,
                    "@",
                    (termAttributeLinkTag a)])
          perLink =
                  Lists.map (\link -> case link of
                    Paths.TermLinkAttribute v0 -> (Just (attrKeyFor v0, (termAttributeLinkValue v0)), ([], []))
                    Paths.TermLinkSubterm v0 ->
                      let step = Paths.subtermLinkStep v0
                          child = Paths.subtermLinkChild v0
                          childPath = childPathFor step
                      in (Logic.ifElse (isLeafNode child) (Just (keyFor childPath, (Paths.termNodeTerm child)), ([], [])) (
                        let sub = encodeTermNode root childPath child
                            childVertex =
                                    PgModel.Vertex {
                                      PgModel.vertexLabel = (PgModel.VertexLabel (PrintModel.type_ (Paths.termNodeType child))),
                                      PgModel.vertexId = (termNodeIdTerm (Paths.TermNodeId {
                                        Paths.termNodeIdRoot = root,
                                        Paths.termNodeIdPath = childPath})),
                                      PgModel.vertexProperties = (Pairs.first sub)}
                        in (Nothing, (Lists.concat2 [
                          childVertex] (Pairs.first (Pairs.second sub)), (Pairs.second (Pairs.second sub))))))
                    Paths.TermLinkReference v0 ->
                      let step = Paths.termReferenceLinkStep v0
                          target = Paths.termReferenceLinkTarget v0
                          edgePath = childPathFor step
                          edgeKey = PrintPaths.subtermPath edgePath
                          noVertices = []
                          noEdges = []
                          noProp = Nothing
                      in (Optionals.match (termReferenceNodeId target) (Optionals.match (termReferencePrimitiveName target) (noProp, (noVertices, noEdges)) (\pname -> (Just (keyFor edgePath, (CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName pname)))), (noVertices, noEdges)))) (\targetId ->
                        let edge =
                                PgModel.Edge {
                                  PgModel.edgeLabel = (PgModel.EdgeLabel edgeKey),
                                  PgModel.edgeId = (CoreModel.TermLiteral (CoreModel.LiteralString (Strings.concat [
                                    CoreModel.unName root,
                                    "#",
                                    edgeKey]))),
                                  PgModel.edgeOut = (termNodeIdTerm nid),
                                  PgModel.edgeIn = (termNodeIdTerm targetId),
                                  PgModel.edgeProperties = Maps.empty}
                        in (noProp, (noVertices, [
                          edge]))))) links
          ownProps = Maps.fromList (Optionals.mapOptional Pairs.first perLink)
          descendants = Lists.map Pairs.second perLink
      in (ownProps, (Lists.concat (Lists.map Pairs.first descendants), (Lists.concat (Lists.map Pairs.second descendants))))

-- | Whether a term-graph node has only attribute links (no subterm or reference links), and so folds into a parent property rather than its own vertex
isLeafNode :: Paths.TermNode -> Bool
isLeafNode node =
    Lists.isEmpty (Lists.filter (\link -> case link of
      Paths.TermLinkAttribute _ -> False
      _ -> True) (Paths.termNodeLinks node))

-- | The variant tag of a term attribute link, used to disambiguate same-path attribute keys
termAttributeLinkTag :: Paths.TermAttributeLink -> String
termAttributeLinkTag attr =
    case attr of
      Paths.TermAttributeLinkCasesTypeName _ -> "casesTypeName"
      Paths.TermAttributeLinkInjectTypeName _ -> "injectTypeName"
      Paths.TermAttributeLinkLambdaDomainGiven _ -> "lambdaDomainGiven"
      Paths.TermAttributeLinkLambdaParameter _ -> "lambdaParameter"
      Paths.TermAttributeLinkLetBindingTypeSchemeGiven _ -> "letBindingTypeSchemeGiven"
      Paths.TermAttributeLinkLiteral _ -> "literal"
      Paths.TermAttributeLinkProjectFieldName _ -> "projectFieldName"
      Paths.TermAttributeLinkProjectTypeName _ -> "projectTypeName"
      Paths.TermAttributeLinkRecordTypeName _ -> "recordTypeName"
      Paths.TermAttributeLinkTypeApplicationType _ -> "typeApplicationType"
      Paths.TermAttributeLinkTypeLambdaParameter _ -> "typeLambdaParameter"
      Paths.TermAttributeLinkUnwrapTypeName _ -> "unwrapTypeName"
      Paths.TermAttributeLinkWrapTypeName _ -> "wrapTypeName"

-- | Encode a term attribute link's payload as a term
termAttributeLinkValue :: Paths.TermAttributeLink -> CoreModel.Term
termAttributeLinkValue attr =
    case attr of
      Paths.TermAttributeLinkCasesTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkInjectTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkLambdaDomainGiven v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (PrintModel.type_ v0))
      Paths.TermAttributeLinkLambdaParameter v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkLetBindingTypeSchemeGiven v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (Strings.concat [
        CoreModel.unName (Pairs.first v0),
        ": ",
        (PrintModel.typeScheme (Pairs.second v0))]))
      Paths.TermAttributeLinkLiteral v0 -> CoreModel.TermLiteral v0
      Paths.TermAttributeLinkProjectFieldName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkProjectTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkRecordTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkTypeApplicationType v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (PrintModel.type_ v0))
      Paths.TermAttributeLinkTypeLambdaParameter v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkUnwrapTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))
      Paths.TermAttributeLinkWrapTypeName v0 -> CoreModel.TermLiteral (CoreModel.LiteralString (CoreModel.unName v0))

-- | Encode a TermNodeId as a term: the root binding name, plus '#' and the printed path if non-empty
termNodeIdTerm :: Paths.TermNodeId -> CoreModel.Term
termNodeIdTerm nid =

      let root = Paths.termNodeIdRoot nid
          path = Paths.termNodeIdPath nid
          steps = Paths.unSubtermPath path
      in (CoreModel.TermLiteral (CoreModel.LiteralString (Logic.ifElse (Lists.isEmpty steps) (CoreModel.unName root) (Strings.concat [
        CoreModel.unName root,
        "#",
        (PrintPaths.subtermPath path)]))))

-- | The binder node id of a lambda- or let-bound variable reference; Nothing for a primitive reference
termReferenceNodeId :: Paths.TermReference -> Maybe Paths.TermNodeId
termReferenceNodeId ref =
    case ref of
      Paths.TermReferenceLambda v0 -> Just (Paths.lambdaVariableReferenceBoundByNode v0)
      Paths.TermReferenceLet v0 -> Just (Paths.letVariableReferenceBindingNode v0)
      Paths.TermReferencePrimitive _ -> Nothing

-- | The primitive's name, for a primitive reference; Nothing otherwise
termReferencePrimitiveName :: Paths.TermReference -> Maybe CoreModel.Name
termReferencePrimitiveName ref =
    case ref of
      Paths.TermReferenceLambda _ -> Nothing
      Paths.TermReferenceLet _ -> Nothing
      Paths.TermReferencePrimitive v0 -> Just (Paths.primitiveReferenceName v0)