{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeOperators #-}

module Unison.Server.Local.Endpoints.DefinitionSummary
  ( TermSummaryAPI,
    serveTermSummary,
    TermSummary (..),
    TypeSummaryAPI,
    serveTypeSummary,
    TypeSummary (..),
  )
where

import Control.Monad.Reader
import Data.Aeson
import Data.OpenApi (ToSchema)
import Servant (Capture, QueryParam, throwError, (:>))
import Servant.Docs (ToSample (..), noSamples)
import Servant.OpenApi ()
import U.Codebase.Causal qualified as V2Causal
import U.Codebase.HashTags (CausalHash)
import U.Codebase.Sqlite.NameLookups (PathSegments (..))
import U.Codebase.Sqlite.Operations qualified as Ops
import Unison.Codebase (Codebase)
import Unison.Codebase qualified as Codebase
import Unison.Codebase.Editor.DisplayObject (DisplayObject (..))
import Unison.Codebase.Path qualified as Path
import Unison.Codebase.ShortCausalHash (ShortCausalHash)
import Unison.Codebase.SqliteCodebase.Conversions qualified as Cv
import Unison.HashQualified qualified as HQ
import Unison.Name (Name)
import Unison.NameSegment.Internal (NameSegment (NameSegment))
import Unison.Parser.Ann (Ann)
import Unison.Prelude
import Unison.PrettyPrintEnvDecl.Sqlite qualified as PPESqlite
import Unison.Reference (Reference)
import Unison.Reference qualified as Reference
import Unison.Referent (Referent)
import Unison.Referent qualified as Referent
import Unison.Server.Backend (Backend)
import Unison.Server.Backend qualified as Backend
import Unison.Server.Syntax (SyntaxText)
import Unison.Server.Types
  ( APIGet,
    TermTag (..),
    TypeTag,
    mayDefaultWidth,
  )
import Unison.ShortHash qualified as SH
import Unison.Symbol (Symbol)
import Unison.Type qualified as Type
import Unison.Util.Pretty (Width)

type TermSummaryAPI =
  "definitions"
    :> "terms"
    :> "by-hash"
    :> Capture "hash" Referent
    :> "summary"
    -- Optional name to include in summary.
    -- It's propagated through to the response as-is.
    -- If missing, the short hash will be used instead.
    :> QueryParam "name" Name
    :> QueryParam "relativeTo" Path.Path
    :> QueryParam "renderWidth" Width
    :> APIGet TermSummary

instance ToSample TermSummary where
  toSamples :: Proxy TermSummary -> [(Text, TermSummary)]
toSamples Proxy TermSummary
_ = [(Text, TermSummary)]
forall a. [(Text, a)]
noSamples

data TermSummary = TermSummary
  { TermSummary -> HashQualified Name
displayName :: HQ.HashQualified Name,
    TermSummary -> ShortHash
hash :: SH.ShortHash,
    TermSummary -> DisplayObject SyntaxText SyntaxText
summary :: DisplayObject SyntaxText SyntaxText,
    TermSummary -> TermTag
tag :: TermTag
  }
  deriving ((forall x. TermSummary -> Rep TermSummary x)
-> (forall x. Rep TermSummary x -> TermSummary)
-> Generic TermSummary
forall x. Rep TermSummary x -> TermSummary
forall x. TermSummary -> Rep TermSummary x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TermSummary -> Rep TermSummary x
from :: forall x. TermSummary -> Rep TermSummary x
$cto :: forall x. Rep TermSummary x -> TermSummary
to :: forall x. Rep TermSummary x -> TermSummary
Generic, Int -> TermSummary -> ShowS
[TermSummary] -> ShowS
TermSummary -> String
(Int -> TermSummary -> ShowS)
-> (TermSummary -> String)
-> ([TermSummary] -> ShowS)
-> Show TermSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermSummary -> ShowS
showsPrec :: Int -> TermSummary -> ShowS
$cshow :: TermSummary -> String
show :: TermSummary -> String
$cshowList :: [TermSummary] -> ShowS
showList :: [TermSummary] -> ShowS
Show)

instance ToJSON TermSummary where
  toJSON :: TermSummary -> Value
toJSON (TermSummary {ShortHash
HashQualified Name
DisplayObject SyntaxText SyntaxText
TermTag
$sel:displayName:TermSummary :: TermSummary -> HashQualified Name
$sel:hash:TermSummary :: TermSummary -> ShortHash
$sel:summary:TermSummary :: TermSummary -> DisplayObject SyntaxText SyntaxText
$sel:tag:TermSummary :: TermSummary -> TermTag
displayName :: HashQualified Name
hash :: ShortHash
summary :: DisplayObject SyntaxText SyntaxText
tag :: TermTag
..}) =
    [Pair] -> Value
object
      [ Key
"displayName" Key -> HashQualified Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= HashQualified Name
displayName,
        Key
"hash" Key -> ShortHash -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= ShortHash
hash,
        Key
"summary" Key -> DisplayObject SyntaxText SyntaxText -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= DisplayObject SyntaxText SyntaxText
summary,
        Key
"tag" Key -> TermTag -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= TermTag
tag
      ]

deriving instance ToSchema TermSummary

serveTermSummary ::
  Codebase IO Symbol Ann ->
  Referent ->
  Maybe Name ->
  Either ShortCausalHash CausalHash ->
  Maybe Path.Path ->
  Maybe Width ->
  Backend IO TermSummary
serveTermSummary :: Codebase IO Symbol Ann
-> Referent
-> Maybe Name
-> Either ShortCausalHash CausalHash
-> Maybe Path
-> Maybe Width
-> Backend IO TermSummary
serveTermSummary Codebase IO Symbol Ann
codebase Referent
referent Maybe Name
mayName Either ShortCausalHash CausalHash
root Maybe Path
relativeTo Maybe Width
mayWidth = do
  let shortHash :: ShortHash
shortHash = Referent -> ShortHash
Referent.toShortHash Referent
referent
  let displayName :: HashQualified Name
displayName = HashQualified Name
-> (Name -> HashQualified Name) -> Maybe Name -> HashQualified Name
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ShortHash -> HashQualified Name
forall n. ShortHash -> HashQualified n
HQ.HashOnly ShortHash
shortHash) Name -> HashQualified Name
forall n. n -> HashQualified n
HQ.NameOnly Maybe Name
mayName
  let relativeToPath :: Path
relativeToPath = Path -> Maybe Path -> Path
forall a. a -> Maybe a -> a
fromMaybe Path
Path.empty Maybe Path
relativeTo
  let termReference :: Reference
termReference = Referent -> Reference
Referent.toReference Referent
referent
  let v2Referent :: Referent
v2Referent = Referent -> Referent
Cv.referent1to2 Referent
referent

  (CausalBranch Transaction
root, Maybe (Type Symbol Ann)
sig) <-
    (forall x. Transaction x -> IO x)
-> Backend
     Transaction (CausalBranch Transaction, Maybe (Type Symbol Ann))
-> Backend IO (CausalBranch Transaction, Maybe (Type Symbol Ann))
forall (m :: * -> *) (n :: * -> *) a.
(forall x. m x -> n x) -> Backend m a -> Backend n a
Backend.hoistBackend (Codebase IO Symbol Ann -> Transaction x -> IO x
forall (m :: * -> *) v a b.
MonadIO m =>
Codebase m v a -> Transaction b -> m b
Codebase.runTransaction Codebase IO Symbol Ann
codebase) do
      CausalBranch Transaction
root <- Either ShortCausalHash CausalHash
-> Backend Transaction (CausalBranch Transaction)
Backend.normaliseRootCausalHash Either ShortCausalHash CausalHash
root
      Maybe (Type Symbol Ann)
sig <- Transaction (Maybe (Type Symbol Ann))
-> Backend Transaction (Maybe (Type Symbol Ann))
forall (m :: * -> *) a. Monad m => m a -> Backend m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Codebase IO Symbol Ann
-> Referent -> Transaction (Maybe (Type Symbol Ann))
forall (m :: * -> *).
Codebase m Symbol Ann
-> Referent -> Transaction (Maybe (Type Symbol Ann))
Backend.loadReferentType Codebase IO Symbol Ann
codebase Referent
referent)
      (CausalBranch Transaction, Maybe (Type Symbol Ann))
-> Backend
     Transaction (CausalBranch Transaction, Maybe (Type Symbol Ann))
forall a. a -> Backend Transaction a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CausalBranch Transaction
root, Maybe (Type Symbol Ann)
sig)
  case Maybe (Type Symbol Ann)
sig of
    Maybe (Type Symbol Ann)
Nothing ->
      BackendError -> Backend IO TermSummary
forall a. BackendError -> Backend IO a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Reference -> BackendError
Backend.MissingSignatureForTerm Reference
termReference)
    Just Type Symbol Ann
typeSig -> do
      PrettyPrintEnvDecl
ppe <-
        (BackendEnv -> Bool) -> Backend IO Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks BackendEnv -> Bool
Backend.useNamesIndex Backend IO Bool
-> (Bool -> Backend IO PrettyPrintEnvDecl)
-> Backend IO PrettyPrintEnvDecl
forall a b. Backend IO a -> (a -> Backend IO b) -> Backend IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
          Bool
True -> do
            let deps :: Set LabeledDependency
deps = Type Symbol Ann -> Set LabeledDependency
forall v a. Ord v => Type v a -> Set LabeledDependency
Type.labeledDependencies Type Symbol Ann
typeSig
            IO PrettyPrintEnvDecl -> Backend IO PrettyPrintEnvDecl
forall a. IO a -> Backend IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PrettyPrintEnvDecl -> Backend IO PrettyPrintEnvDecl)
-> (Transaction PrettyPrintEnvDecl -> IO PrettyPrintEnvDecl)
-> Transaction PrettyPrintEnvDecl
-> Backend IO PrettyPrintEnvDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Codebase IO Symbol Ann
-> Transaction PrettyPrintEnvDecl -> IO PrettyPrintEnvDecl
forall (m :: * -> *) v a b.
MonadIO m =>
Codebase m v a -> Transaction b -> m b
Codebase.runTransaction Codebase IO Symbol Ann
codebase (Transaction PrettyPrintEnvDecl -> Backend IO PrettyPrintEnvDecl)
-> Transaction PrettyPrintEnvDecl -> Backend IO PrettyPrintEnvDecl
forall a b. (a -> b) -> a -> b
$ do
              NamesPerspective
namesPerspective <- BranchHash -> PathSegments -> Transaction NamesPerspective
Ops.namesPerspectiveForRootAndPath (CausalBranch Transaction -> BranchHash
forall (m :: * -> *) hc he pe e. Causal m hc he pe e -> he
V2Causal.valueHash CausalBranch Transaction
root) ([NameSegment] -> PathSegments
forall a b. Coercible a b => a -> b
coerce ([NameSegment] -> PathSegments)
-> (Path -> [NameSegment]) -> Path -> PathSegments
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> [NameSegment]
Path.toList (Path -> PathSegments) -> Path -> PathSegments
forall a b. (a -> b) -> a -> b
$ Path -> Maybe Path -> Path
forall a. a -> Maybe a -> a
fromMaybe Path
Path.Empty Maybe Path
relativeTo)
              NamesPerspective
-> Set LabeledDependency -> Transaction PrettyPrintEnvDecl
PPESqlite.ppedForReferences NamesPerspective
namesPerspective Set LabeledDependency
deps
          Bool
False -> do
            (Names
_localNames, PrettyPrintEnvDecl
ppe) <- Codebase IO Symbol Ann
-> CausalBranch Transaction
-> Path
-> Backend IO (Names, PrettyPrintEnvDecl)
forall (m :: * -> *) (n :: * -> *) v a.
MonadIO m =>
Codebase m v a
-> CausalBranch n -> Path -> Backend m (Names, PrettyPrintEnvDecl)
Backend.namesAtPathFromRootBranchHash Codebase IO Symbol Ann
codebase CausalBranch Transaction
root Path
relativeToPath
            PrettyPrintEnvDecl -> Backend IO PrettyPrintEnvDecl
forall a. a -> Backend IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PrettyPrintEnvDecl
ppe
      let formattedTermSig :: SyntaxText
formattedTermSig = PrettyPrintEnvDecl -> Width -> Type Symbol Ann -> SyntaxText
forall v.
Var v =>
PrettyPrintEnvDecl -> Width -> Type v Ann -> SyntaxText
Backend.formatSuffixedType PrettyPrintEnvDecl
ppe Width
width Type Symbol Ann
typeSig
      let summary :: DisplayObject SyntaxText SyntaxText
summary = Reference -> SyntaxText -> DisplayObject SyntaxText SyntaxText
forall {a}. Reference -> a -> DisplayObject a a
mkSummary Reference
termReference SyntaxText
formattedTermSig
      TermTag
tag <- IO TermTag -> Backend IO TermTag
forall (m :: * -> *) a. Monad m => m a -> Backend m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO TermTag -> Backend IO TermTag)
-> IO TermTag -> Backend IO TermTag
forall a b. (a -> b) -> a -> b
$ Codebase IO Symbol Ann
-> Referent -> Maybe (Type Symbol Ann) -> IO TermTag
forall v (m :: * -> *) a.
(Var v, MonadIO m) =>
Codebase m v a -> Referent -> Maybe (Type v Ann) -> m TermTag
Backend.getTermTag Codebase IO Symbol Ann
codebase Referent
v2Referent Maybe (Type Symbol Ann)
sig
      TermSummary -> Backend IO TermSummary
forall a. a -> Backend IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TermSummary -> Backend IO TermSummary)
-> TermSummary -> Backend IO TermSummary
forall a b. (a -> b) -> a -> b
$ HashQualified Name
-> ShortHash
-> DisplayObject SyntaxText SyntaxText
-> TermTag
-> TermSummary
TermSummary HashQualified Name
displayName ShortHash
shortHash DisplayObject SyntaxText SyntaxText
summary TermTag
tag
  where
    width :: Width
width = Maybe Width -> Width
mayDefaultWidth Maybe Width
mayWidth

    mkSummary :: Reference -> a -> DisplayObject a a
mkSummary Reference
reference a
termSig =
      if Reference -> Bool
Reference.isBuiltin Reference
reference
        then a -> DisplayObject a a
forall b a. b -> DisplayObject b a
BuiltinObject a
termSig
        else a -> DisplayObject a a
forall b a. a -> DisplayObject b a
UserObject a
termSig

type TypeSummaryAPI =
  "definitions"
    :> "types"
    :> "by-hash"
    :> Capture "hash" Reference
    :> "summary"
    -- Optional name to include in summary.
    -- It's propagated through to the response as-is.
    -- If missing, the short hash will be used instead.
    :> QueryParam "name" Name
    :> QueryParam "relativeTo" Path.Path
    :> QueryParam "renderWidth" Width
    :> APIGet TypeSummary

instance ToSample TypeSummary where
  toSamples :: Proxy TypeSummary -> [(Text, TypeSummary)]
toSamples Proxy TypeSummary
_ = [(Text, TypeSummary)]
forall a. [(Text, a)]
noSamples

data TypeSummary = TypeSummary
  { TypeSummary -> HashQualified Name
displayName :: HQ.HashQualified Name,
    TypeSummary -> ShortHash
hash :: SH.ShortHash,
    TypeSummary -> DisplayObject SyntaxText SyntaxText
summary :: DisplayObject SyntaxText SyntaxText,
    TypeSummary -> TypeTag
tag :: TypeTag
  }
  deriving ((forall x. TypeSummary -> Rep TypeSummary x)
-> (forall x. Rep TypeSummary x -> TypeSummary)
-> Generic TypeSummary
forall x. Rep TypeSummary x -> TypeSummary
forall x. TypeSummary -> Rep TypeSummary x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypeSummary -> Rep TypeSummary x
from :: forall x. TypeSummary -> Rep TypeSummary x
$cto :: forall x. Rep TypeSummary x -> TypeSummary
to :: forall x. Rep TypeSummary x -> TypeSummary
Generic, Int -> TypeSummary -> ShowS
[TypeSummary] -> ShowS
TypeSummary -> String
(Int -> TypeSummary -> ShowS)
-> (TypeSummary -> String)
-> ([TypeSummary] -> ShowS)
-> Show TypeSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeSummary -> ShowS
showsPrec :: Int -> TypeSummary -> ShowS
$cshow :: TypeSummary -> String
show :: TypeSummary -> String
$cshowList :: [TypeSummary] -> ShowS
showList :: [TypeSummary] -> ShowS
Show)

instance ToJSON TypeSummary where
  toJSON :: TypeSummary -> Value
toJSON (TypeSummary {ShortHash
HashQualified Name
DisplayObject SyntaxText SyntaxText
TypeTag
$sel:displayName:TypeSummary :: TypeSummary -> HashQualified Name
$sel:hash:TypeSummary :: TypeSummary -> ShortHash
$sel:summary:TypeSummary :: TypeSummary -> DisplayObject SyntaxText SyntaxText
$sel:tag:TypeSummary :: TypeSummary -> TypeTag
displayName :: HashQualified Name
hash :: ShortHash
summary :: DisplayObject SyntaxText SyntaxText
tag :: TypeTag
..}) =
    [Pair] -> Value
object
      [ Key
"displayName" Key -> HashQualified Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= HashQualified Name
displayName,
        Key
"hash" Key -> ShortHash -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= ShortHash
hash,
        Key
"summary" Key -> DisplayObject SyntaxText SyntaxText -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= DisplayObject SyntaxText SyntaxText
summary,
        Key
"tag" Key -> TypeTag -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= TypeTag
tag
      ]

deriving instance ToSchema TypeSummary

serveTypeSummary ::
  Codebase IO Symbol Ann ->
  Reference ->
  Maybe Name ->
  Either ShortCausalHash CausalHash ->
  Maybe Path.Path ->
  Maybe Width ->
  Backend IO TypeSummary
serveTypeSummary :: Codebase IO Symbol Ann
-> Reference
-> Maybe Name
-> Either ShortCausalHash CausalHash
-> Maybe Path
-> Maybe Width
-> Backend IO TypeSummary
serveTypeSummary Codebase IO Symbol Ann
codebase Reference
reference Maybe Name
mayName Either ShortCausalHash CausalHash
_mayRoot Maybe Path
_relativeTo Maybe Width
mayWidth = do
  let shortHash :: ShortHash
shortHash = Reference -> ShortHash
Reference.toShortHash Reference
reference
  let displayName :: HashQualified Name
displayName = HashQualified Name
-> (Name -> HashQualified Name) -> Maybe Name -> HashQualified Name
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ShortHash -> HashQualified Name
forall n. ShortHash -> HashQualified n
HQ.HashOnly ShortHash
shortHash) Name -> HashQualified Name
forall n. n -> HashQualified n
HQ.NameOnly Maybe Name
mayName
  (TypeTag
tag, DisplayObject () (Decl Symbol Ann)
displayDecl) <-
    IO (TypeTag, DisplayObject () (Decl Symbol Ann))
-> Backend IO (TypeTag, DisplayObject () (Decl Symbol Ann))
forall (m :: * -> *) a. Monad m => m a -> Backend m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift do
      Codebase IO Symbol Ann
-> Transaction (TypeTag, DisplayObject () (Decl Symbol Ann))
-> IO (TypeTag, DisplayObject () (Decl Symbol Ann))
forall (m :: * -> *) v a b.
MonadIO m =>
Codebase m v a -> Transaction b -> m b
Codebase.runTransaction Codebase IO Symbol Ann
codebase do
        TypeTag
tag <- Codebase IO Symbol Ann -> Reference -> Transaction TypeTag
forall v (m :: * -> *).
Var v =>
Codebase m v Ann -> Reference -> Transaction TypeTag
Backend.getTypeTag Codebase IO Symbol Ann
codebase Reference
reference
        DisplayObject () (Decl Symbol Ann)
displayDecl <- Codebase IO Symbol Ann
-> Reference -> Transaction (DisplayObject () (Decl Symbol Ann))
forall (m :: * -> *).
Codebase m Symbol Ann
-> Reference -> Transaction (DisplayObject () (Decl Symbol Ann))
Backend.displayType Codebase IO Symbol Ann
codebase Reference
reference
        (TypeTag, DisplayObject () (Decl Symbol Ann))
-> Transaction (TypeTag, DisplayObject () (Decl Symbol Ann))
forall a. a -> Transaction a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeTag
tag, DisplayObject () (Decl Symbol Ann)
displayDecl)
  let syntaxHeader :: DisplayObject SyntaxText SyntaxText
syntaxHeader = Width
-> HashQualified Name
-> DisplayObject () (Decl Symbol Ann)
-> DisplayObject SyntaxText SyntaxText
Backend.typeToSyntaxHeader Width
width HashQualified Name
displayName DisplayObject () (Decl Symbol Ann)
displayDecl
  TypeSummary -> Backend IO TypeSummary
forall a. a -> Backend IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeSummary -> Backend IO TypeSummary)
-> TypeSummary -> Backend IO TypeSummary
forall a b. (a -> b) -> a -> b
$
    TypeSummary
      { $sel:displayName:TypeSummary :: HashQualified Name
displayName = HashQualified Name
displayName,
        $sel:hash:TypeSummary :: ShortHash
hash = ShortHash
shortHash,
        $sel:summary:TypeSummary :: DisplayObject SyntaxText SyntaxText
summary = (SyntaxText -> SyntaxText)
-> (SyntaxText -> SyntaxText)
-> DisplayObject SyntaxText SyntaxText
-> DisplayObject SyntaxText SyntaxText
forall a b c d.
(a -> b) -> (c -> d) -> DisplayObject a c -> DisplayObject b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap SyntaxText -> SyntaxText
forall (g :: * -> *).
Functor g =>
g (Element Reference) -> g Element
Backend.mungeSyntaxText SyntaxText -> SyntaxText
forall (g :: * -> *).
Functor g =>
g (Element Reference) -> g Element
Backend.mungeSyntaxText DisplayObject SyntaxText SyntaxText
syntaxHeader,
        $sel:tag:TypeSummary :: TypeTag
tag = TypeTag
tag
      }
  where
    width :: Width
width = Maybe Width -> Width
mayDefaultWidth Maybe Width
mayWidth