-- | Description: Converts V2 types to the V2 hashing types
module Unison.Hashing.V2.Convert2
  ( convertBranchV3,
    v2ToH2Type,
    v2ToH2TypeD,
    h2ToV2Reference,
    v2ToH2Referent,
    v2ToH2Branch,
    v2ToH2Term,
    v2ToH2Decl,
    hashBranchFormatToH2Branch,
    hashPatchFormatToH2Patch,
  )
where

import Data.Map qualified as Map
import Data.Set qualified as Set
import Data.Text qualified as Text
import U.Codebase.Branch qualified as V2
import U.Codebase.Branch qualified as V2Branch
import U.Codebase.BranchV3 (BranchV3 (..))
import U.Codebase.Causal qualified as Causal
import U.Codebase.Decl qualified as V2.Decl
import U.Codebase.HashTags
import U.Codebase.Kind qualified as V2
import U.Codebase.Reference qualified as V2
import U.Codebase.Reference qualified as V2Reference
import U.Codebase.Referent qualified as V2Referent
import U.Codebase.Sqlite.Branch.Full qualified as Memory.BranchFull
import U.Codebase.Sqlite.Patch.Full qualified as Memory.PatchFull
import U.Codebase.Sqlite.Patch.TermEdit qualified as Memory.TermEdit
import U.Codebase.Sqlite.Patch.TypeEdit qualified as Memory.TypeEdit
import U.Codebase.Term qualified as V2 (TypeRef)
import U.Codebase.Term qualified as V2.Term
import U.Codebase.Type qualified as V2.Type
import U.Core.ABT qualified as ABT
import Unison.Hash (Hash)
import Unison.Hashing.V2 qualified as H2
import Unison.NameSegment.Internal (NameSegment (NameSegment))
import Unison.Prelude
import Unison.Symbol qualified as Unison
import Unison.Util.Map qualified as Map

-- | Convert a V3 branch to a hashing branch.
convertBranchV3 :: BranchV3 m -> H2.Branch
convertBranchV3 :: forall (m :: * -> *). BranchV3 m -> Branch
convertBranchV3 BranchV3 {Map NameSegment (CausalBranchV3 m)
children :: Map NameSegment (CausalBranchV3 m)
$sel:children:BranchV3 :: forall (m :: * -> *).
BranchV3 m -> Map NameSegment (CausalBranchV3 m)
children, Map NameSegment Referent
terms :: Map NameSegment Referent
$sel:terms:BranchV3 :: forall (m :: * -> *). BranchV3 m -> Map NameSegment Referent
terms, Map NameSegment Reference
types :: Map NameSegment Reference
$sel:types:BranchV3 :: forall (m :: * -> *). BranchV3 m -> Map NameSegment Reference
types} =
  H2.Branch
    { children :: Map NameSegment Hash
children = Map NameSegment (CausalBranchV3 m)
children Map NameSegment (CausalBranchV3 m)
-> (Map NameSegment (CausalBranchV3 m) -> Map NameSegment Hash)
-> Map NameSegment Hash
forall a b. a -> (a -> b) -> b
& (NameSegment -> NameSegment)
-> (CausalBranchV3 m -> Hash)
-> Map NameSegment (CausalBranchV3 m)
-> Map NameSegment Hash
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce (CausalHash -> Hash
unCausalHash (CausalHash -> Hash)
-> (CausalBranchV3 m -> CausalHash) -> CausalBranchV3 m -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CausalBranchV3 m -> CausalHash
forall (m :: * -> *) hc he pe e. Causal m hc he pe e -> hc
Causal.causalHash),
      patches :: Map NameSegment Hash
patches = Map NameSegment Hash
forall k a. Map k a
Map.empty,
      terms :: Map NameSegment (Map Referent MdValues)
terms = (NameSegment -> NameSegment)
-> (Referent -> Map Referent MdValues)
-> Map NameSegment Referent
-> Map NameSegment (Map Referent MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce (\Referent
ref -> Referent -> MdValues -> Map Referent MdValues
forall k a. k -> a -> Map k a
Map.singleton (Referent -> Referent
v2ToH2Referent Referent
ref) MdValues
emptyMetadata) Map NameSegment Referent
terms,
      types :: Map NameSegment (Map Reference MdValues)
types = (NameSegment -> NameSegment)
-> (Reference -> Map Reference MdValues)
-> Map NameSegment Reference
-> Map NameSegment (Map Reference MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce (\Reference
ref -> Reference -> MdValues -> Map Reference MdValues
forall k a. k -> a -> Map k a
Map.singleton (Reference -> Reference
v2ToH2Reference Reference
ref) MdValues
emptyMetadata) Map NameSegment Reference
types
    }
  where
    emptyMetadata :: MdValues
emptyMetadata = Set Reference -> MdValues
H2.MdValues Set Reference
forall a. Set a
Set.empty

convertId :: Hash -> V2Reference.Id' (Maybe Hash) -> H2.ReferenceId
convertId :: Hash -> Id' (Maybe Hash) -> ReferenceId
convertId Hash
defaultHash = \case
  V2.Id Maybe Hash
m Pos
p -> Hash -> Pos -> ReferenceId
H2.ReferenceId (Hash -> Maybe Hash -> Hash
forall a. a -> Maybe a -> a
fromMaybe Hash
defaultHash Maybe Hash
m) Pos
p

v2ToH2Reference :: V2.Reference -> H2.Reference
v2ToH2Reference :: Reference -> Reference
v2ToH2Reference = (Id' Hash -> ReferenceId) -> Reference -> Reference
forall hash.
(Id' hash -> ReferenceId) -> Reference' Text hash -> Reference
convertReference' (\(V2.Id Hash
a Pos
b) -> Hash -> Pos -> ReferenceId
H2.ReferenceId Hash
a Pos
b)

convertReference' :: (V2Reference.Id' hash -> H2.ReferenceId) -> V2.Reference' Text hash -> H2.Reference
convertReference' :: forall hash.
(Id' hash -> ReferenceId) -> Reference' Text hash -> Reference
convertReference' Id' hash -> ReferenceId
idConv = \case
  V2.ReferenceBuiltin Text
x -> Text -> Reference
H2.ReferenceBuiltin Text
x
  V2.ReferenceDerived Id' hash
x -> ReferenceId -> Reference
H2.ReferenceDerivedId (Id' hash -> ReferenceId
idConv Id' hash
x)

v2ToH2Type :: forall v. (Ord v) => V2.Type.TypeR V2.TypeRef v -> H2.Type v ()
v2ToH2Type :: forall v. Ord v => TypeR Reference v -> Type v ()
v2ToH2Type = (Reference -> Reference) -> TypeR Reference v -> Type v ()
forall r v. Ord v => (r -> Reference) -> TypeR r v -> Type v ()
v2ToH2Type' Reference -> Reference
v2ToH2Reference

v2ToH2TypeD :: forall v. (Ord v) => Hash -> V2.Type.TypeD v -> H2.Type v ()
v2ToH2TypeD :: forall v. Ord v => Hash -> TypeD v -> Type v ()
v2ToH2TypeD Hash
defaultHash = (Reference' Text (Maybe Hash) -> Reference)
-> TypeR (Reference' Text (Maybe Hash)) v -> Type v ()
forall r v. Ord v => (r -> Reference) -> TypeR r v -> Type v ()
v2ToH2Type' ((Id' (Maybe Hash) -> ReferenceId)
-> Reference' Text (Maybe Hash) -> Reference
forall hash.
(Id' hash -> ReferenceId) -> Reference' Text hash -> Reference
convertReference' (Hash -> Id' (Maybe Hash) -> ReferenceId
convertId Hash
defaultHash))

v2ToH2Type' :: forall r v. (Ord v) => (r -> H2.Reference) -> V2.Type.TypeR r v -> H2.Type v ()
v2ToH2Type' :: forall r v. Ord v => (r -> Reference) -> TypeR r v -> Type v ()
v2ToH2Type' r -> Reference
mkReference = (forall a1. F' r a1 -> TypeF a1)
-> Term (F' r) v () -> Term TypeF v ()
forall v (g :: * -> *) (f :: * -> *) a.
(Ord v, Foldable g, Functor g) =>
(forall a1. f a1 -> g a1) -> Term f v a -> Term g v a
ABT.transform F' r a1 -> TypeF a1
forall a1. F' r a1 -> TypeF a1
convertF
  where
    convertF :: forall a. V2.Type.F' r a -> H2.TypeF a
    convertF :: forall a1. F' r a1 -> TypeF a1
convertF = \case
      V2.Type.Ref r
x -> Reference -> TypeF a
forall a. Reference -> TypeF a
H2.TypeRef (r -> Reference
mkReference r
x)
      V2.Type.Arrow a
a a
b -> a -> a -> TypeF a
forall a. a -> a -> TypeF a
H2.TypeArrow a
a a
b
      V2.Type.Ann a
a Kind
k -> a -> Kind -> TypeF a
forall a. a -> Kind -> TypeF a
H2.TypeAnn a
a (Kind -> Kind
convertKind Kind
k)
      V2.Type.App a
a a
b -> a -> a -> TypeF a
forall a. a -> a -> TypeF a
H2.TypeApp a
a a
b
      V2.Type.Effect a
a a
b -> a -> a -> TypeF a
forall a. a -> a -> TypeF a
H2.TypeEffect a
a a
b
      V2.Type.Effects [a]
a -> [a] -> TypeF a
forall a. [a] -> TypeF a
H2.TypeEffects [a]
a
      V2.Type.Forall a
a -> a -> TypeF a
forall a. a -> TypeF a
H2.TypeForall a
a
      V2.Type.IntroOuter a
a -> a -> TypeF a
forall a. a -> TypeF a
H2.TypeIntroOuter a
a

convertKind :: V2.Kind -> H2.Kind
convertKind :: Kind -> Kind
convertKind = \case
  Kind
V2.Star -> Kind
H2.KindStar
  V2.Arrow Kind
a Kind
b -> Kind -> Kind -> Kind
H2.KindArrow (Kind -> Kind
convertKind Kind
a) (Kind -> Kind
convertKind Kind
b)

h2ToV2Reference :: H2.Reference -> V2.Reference
h2ToV2Reference :: Reference -> Reference
h2ToV2Reference = \case
  H2.ReferenceBuiltin Text
txt -> Text -> Reference
forall t h. t -> Reference' t h
V2.ReferenceBuiltin Text
txt
  H2.ReferenceDerivedId (H2.ReferenceId Hash
x Pos
y) -> Id' Hash -> Reference
forall t h. Id' h -> Reference' t h
V2.ReferenceDerived (Hash -> Pos -> Id' Hash
forall h. h -> Pos -> Id' h
V2.Id Hash
x Pos
y)

v2ToH2Referent :: V2Referent.Referent -> H2.Referent
v2ToH2Referent :: Referent -> Referent
v2ToH2Referent = \case
  V2Referent.Ref Reference
r -> Reference -> Referent
H2.ReferentRef (Reference -> Reference
v2ToH2Reference Reference
r)
  V2Referent.Con Reference
r Pos
cid -> Reference -> Pos -> Referent
H2.ReferentCon (Reference -> Reference
v2ToH2Reference Reference
r) Pos
cid

v2ToH2Branch :: (Monad m) => V2.Branch m -> m H2.Branch
v2ToH2Branch :: forall (m :: * -> *). Monad m => Branch m -> m Branch
v2ToH2Branch V2.Branch {Map NameSegment (Map Referent (m MdValues))
terms :: Map NameSegment (Map Referent (m MdValues))
$sel:terms:Branch :: forall (m :: * -> *).
Branch m -> Map NameSegment (Map Referent (m MdValues))
terms, Map NameSegment (Map Reference (m MdValues))
types :: Map NameSegment (Map Reference (m MdValues))
$sel:types:Branch :: forall (m :: * -> *).
Branch m -> Map NameSegment (Map Reference (m MdValues))
types, Map NameSegment (PatchHash, m Patch)
patches :: Map NameSegment (PatchHash, m Patch)
$sel:patches:Branch :: forall (m :: * -> *).
Branch m -> Map NameSegment (PatchHash, m Patch)
patches, Map NameSegment (CausalBranch m)
children :: Map NameSegment (CausalBranch m)
$sel:children:Branch :: forall (m :: * -> *). Branch m -> Map NameSegment (CausalBranch m)
children} = do
  Map NameSegment (Map Referent MdValues)
hterms <-
    (Map Referent (m MdValues) -> m (Map Referent MdValues))
-> Map NameSegment (Map Referent (m MdValues))
-> m (Map NameSegment (Map Referent MdValues))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Map NameSegment a -> f (Map NameSegment b)
traverse Map Referent (m MdValues) -> m (Map Referent MdValues)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
Map Referent (f a) -> f (Map Referent a)
sequenceA Map NameSegment (Map Referent (m MdValues))
terms
      m (Map NameSegment (Map Referent MdValues))
-> (Map NameSegment (Map Referent MdValues)
    -> Map NameSegment (Map Referent MdValues))
-> m (Map NameSegment (Map Referent MdValues))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (NameSegment -> NameSegment)
-> (Map Referent MdValues -> Map Referent MdValues)
-> Map NameSegment (Map Referent MdValues)
-> Map NameSegment (Map Referent MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce ((Referent -> Referent)
-> (MdValues -> MdValues)
-> Map Referent MdValues
-> Map Referent MdValues
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Referent -> Referent
v2ToH2Referent MdValues -> MdValues
v2ToH2MdValues)
  Map NameSegment (Map Reference MdValues)
htypes <-
    (Map Reference (m MdValues) -> m (Map Reference MdValues))
-> Map NameSegment (Map Reference (m MdValues))
-> m (Map NameSegment (Map Reference MdValues))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Map NameSegment a -> f (Map NameSegment b)
traverse Map Reference (m MdValues) -> m (Map Reference MdValues)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
Map Reference (f a) -> f (Map Reference a)
sequenceA Map NameSegment (Map Reference (m MdValues))
types
      m (Map NameSegment (Map Reference MdValues))
-> (Map NameSegment (Map Reference MdValues)
    -> Map NameSegment (Map Reference MdValues))
-> m (Map NameSegment (Map Reference MdValues))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (NameSegment -> NameSegment)
-> (Map Reference MdValues -> Map Reference MdValues)
-> Map NameSegment (Map Reference MdValues)
-> Map NameSegment (Map Reference MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce ((Reference -> Reference)
-> (MdValues -> MdValues)
-> Map Reference MdValues
-> Map Reference MdValues
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Reference -> Reference
v2ToH2Reference MdValues -> MdValues
v2ToH2MdValues)
  let hpatches :: Map NameSegment Hash
hpatches =
        Map NameSegment (PatchHash, m Patch)
patches
          Map NameSegment (PatchHash, m Patch)
-> (Map NameSegment (PatchHash, m Patch) -> Map NameSegment Hash)
-> Map NameSegment Hash
forall a b. a -> (a -> b) -> b
& (NameSegment -> NameSegment)
-> ((PatchHash, m Patch) -> Hash)
-> Map NameSegment (PatchHash, m Patch)
-> Map NameSegment Hash
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce (PatchHash -> Hash
unPatchHash (PatchHash -> Hash)
-> ((PatchHash, m Patch) -> PatchHash)
-> (PatchHash, m Patch)
-> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PatchHash, m Patch) -> PatchHash
forall a b. (a, b) -> a
fst)
  let hchildren :: Map NameSegment Hash
hchildren = Map NameSegment (CausalBranch m)
children Map NameSegment (CausalBranch m)
-> (Map NameSegment (CausalBranch m) -> Map NameSegment Hash)
-> Map NameSegment Hash
forall a b. a -> (a -> b) -> b
& (NameSegment -> NameSegment)
-> (CausalBranch m -> Hash)
-> Map NameSegment (CausalBranch m)
-> Map NameSegment Hash
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap NameSegment -> NameSegment
forall a b. Coercible a b => a -> b
coerce (CausalHash -> Hash
unCausalHash (CausalHash -> Hash)
-> (CausalBranch m -> CausalHash) -> CausalBranch m -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CausalBranch m -> CausalHash
forall (m :: * -> *) hc he pe e. Causal m hc he pe e -> hc
Causal.causalHash)
  pure $ H2.Branch {types :: Map NameSegment (Map Reference MdValues)
types = Map NameSegment (Map Reference MdValues)
htypes, terms :: Map NameSegment (Map Referent MdValues)
terms = Map NameSegment (Map Referent MdValues)
hterms, patches :: Map NameSegment Hash
patches = Map NameSegment Hash
hpatches, children :: Map NameSegment Hash
children = Map NameSegment Hash
hchildren}

v2ToH2MdValues :: V2Branch.MdValues -> H2.MdValues
v2ToH2MdValues :: MdValues -> MdValues
v2ToH2MdValues (V2Branch.MdValues Set Reference
mdMap) =
  Set Reference
mdMap
    Set Reference -> (Set Reference -> Set Reference) -> Set Reference
forall a b. a -> (a -> b) -> b
& (Reference -> Reference) -> Set Reference -> Set Reference
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Reference -> Reference
v2ToH2Reference
    Set Reference -> (Set Reference -> MdValues) -> MdValues
forall a b. a -> (a -> b) -> b
& Set Reference -> MdValues
H2.MdValues

hashBranchFormatToH2Branch :: Memory.BranchFull.HashBranch -> H2.Branch
hashBranchFormatToH2Branch :: HashBranch -> Branch
hashBranchFormatToH2Branch Memory.BranchFull.Branch {Map
  Text
  (Map
     (Referent' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
terms :: Map
  Text
  (Map
     (Referent' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
$sel:terms:Branch :: forall t h p c.
Branch' t h p c
-> Map t (Map (Referent'' t h) (MetadataSetFormat' t h))
terms, Map
  Text
  (Map
     (Reference' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
types :: Map
  Text
  (Map
     (Reference' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
$sel:types:Branch :: forall t h p c.
Branch' t h p c
-> Map t (Map (TypeReference' t h) (MetadataSetFormat' t h))
types, Map Text PatchHash
patches :: Map Text PatchHash
$sel:patches:Branch :: forall t h p c. Branch' t h p c -> Map t p
patches, Map Text (BranchHash, CausalHash)
children :: Map Text (BranchHash, CausalHash)
$sel:children:Branch :: forall t h p c. Branch' t h p c -> Map t c
children} =
  H2.Branch
    { terms :: Map NameSegment (Map Referent MdValues)
terms =
        Map
  Text
  (Map
     (Referent' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
terms
          Map
  Text
  (Map
     (Referent' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
-> (Map
      Text
      (Map
         (Referent' Text ComponentHash)
         (MetadataSetFormat' Text ComponentHash))
    -> Map NameSegment (Map Referent MdValues))
-> Map NameSegment (Map Referent MdValues)
forall a b. a -> (a -> b) -> b
& (Text -> NameSegment)
-> (Map
      (Referent' Text ComponentHash)
      (MetadataSetFormat' Text ComponentHash)
    -> Map Referent MdValues)
-> Map
     Text
     (Map
        (Referent' Text ComponentHash)
        (MetadataSetFormat' Text ComponentHash))
-> Map NameSegment (Map Referent MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Text -> NameSegment
H2.NameSegment ((Referent' Text ComponentHash -> Referent)
-> (MetadataSetFormat' Text ComponentHash -> MdValues)
-> Map
     (Referent' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash)
-> Map Referent MdValues
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Referent' Text ComponentHash -> Referent
cvreferent MetadataSetFormat' Text ComponentHash -> MdValues
cvMdValues),
      types :: Map NameSegment (Map Reference MdValues)
types =
        Map
  Text
  (Map
     (Reference' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
types
          Map
  Text
  (Map
     (Reference' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash))
-> (Map
      Text
      (Map
         (Reference' Text ComponentHash)
         (MetadataSetFormat' Text ComponentHash))
    -> Map NameSegment (Map Reference MdValues))
-> Map NameSegment (Map Reference MdValues)
forall a b. a -> (a -> b) -> b
& (Text -> NameSegment)
-> (Map
      (Reference' Text ComponentHash)
      (MetadataSetFormat' Text ComponentHash)
    -> Map Reference MdValues)
-> Map
     Text
     (Map
        (Reference' Text ComponentHash)
        (MetadataSetFormat' Text ComponentHash))
-> Map NameSegment (Map Reference MdValues)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Text -> NameSegment
H2.NameSegment ((Reference' Text ComponentHash -> Reference)
-> (MetadataSetFormat' Text ComponentHash -> MdValues)
-> Map
     (Reference' Text ComponentHash)
     (MetadataSetFormat' Text ComponentHash)
-> Map Reference MdValues
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Reference' Text ComponentHash -> Reference
cvreference MetadataSetFormat' Text ComponentHash -> MdValues
cvMdValues),
      patches :: Map NameSegment Hash
patches = Map Text PatchHash
patches Map Text PatchHash
-> (Map Text PatchHash -> Map NameSegment Hash)
-> Map NameSegment Hash
forall a b. a -> (a -> b) -> b
& (Text -> NameSegment)
-> (PatchHash -> Hash)
-> Map Text PatchHash
-> Map NameSegment Hash
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Text -> NameSegment
H2.NameSegment PatchHash -> Hash
unPatchHash,
      children :: Map NameSegment Hash
children = Map Text (BranchHash, CausalHash)
children Map Text (BranchHash, CausalHash)
-> (Map Text (BranchHash, CausalHash) -> Map NameSegment Hash)
-> Map NameSegment Hash
forall a b. a -> (a -> b) -> b
& (Text -> NameSegment)
-> ((BranchHash, CausalHash) -> Hash)
-> Map Text (BranchHash, CausalHash)
-> Map NameSegment Hash
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Text -> NameSegment
H2.NameSegment (CausalHash -> Hash
unCausalHash (CausalHash -> Hash)
-> ((BranchHash, CausalHash) -> CausalHash)
-> (BranchHash, CausalHash)
-> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BranchHash, CausalHash) -> CausalHash
forall a b. (a, b) -> b
snd)
    }
  where
    cvMdValues :: Memory.BranchFull.MetadataSetFormat' Text ComponentHash -> H2.MdValues
    cvMdValues :: MetadataSetFormat' Text ComponentHash -> MdValues
cvMdValues (Memory.BranchFull.Inline Set (Reference' Text ComponentHash)
refSet) = Set Reference -> MdValues
H2.MdValues (Set Reference -> MdValues) -> Set Reference -> MdValues
forall a b. (a -> b) -> a -> b
$ (Reference' Text ComponentHash -> Reference)
-> Set (Reference' Text ComponentHash) -> Set Reference
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Reference' Text ComponentHash -> Reference
cvreference Set (Reference' Text ComponentHash)
refSet
    cvreference :: V2Reference.Reference' Text ComponentHash -> H2.Reference
    cvreference :: Reference' Text ComponentHash -> Reference
cvreference = Reference -> Reference
v2ToH2Reference (Reference -> Reference)
-> (Reference' Text ComponentHash -> Reference)
-> Reference' Text ComponentHash
-> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash
    cvreferent :: Memory.BranchFull.Referent'' Text ComponentHash -> H2.Referent
    cvreferent :: Referent' Text ComponentHash -> Referent
cvreferent = \case
      V2Referent.Ref Reference' Text ComponentHash
ref -> (Reference -> Referent
H2.ReferentRef (Reference -> Reference
v2ToH2Reference (Reference -> Reference) -> Reference -> Reference
forall a b. (a -> b) -> a -> b
$ (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash Reference' Text ComponentHash
ref))
      V2Referent.Con Reference' Text ComponentHash
typeRef Pos
conId -> do
        (Reference -> Pos -> Referent
H2.ReferentCon (Reference -> Reference
v2ToH2Reference (Reference -> Reference) -> Reference -> Reference
forall a b. (a -> b) -> a -> b
$ (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash Reference' Text ComponentHash
typeRef) Pos
conId)

hashPatchFormatToH2Patch :: Memory.PatchFull.HashPatch -> H2.Patch
hashPatchFormatToH2Patch :: HashPatch -> Patch
hashPatchFormatToH2Patch Memory.PatchFull.Patch {Map
  (Referent' Text ComponentHash) (Set (TermEdit' Text ComponentHash))
termEdits :: Map
  (Referent' Text ComponentHash) (Set (TermEdit' Text ComponentHash))
$sel:termEdits:Patch :: forall t h o.
Patch' t h o -> Map (Referent'' t h) (Set (TermEdit' t o))
termEdits, Map
  (Reference' Text ComponentHash)
  (Set (TypeEdit' Text ComponentHash))
typeEdits :: Map
  (Reference' Text ComponentHash)
  (Set (TypeEdit' Text ComponentHash))
$sel:typeEdits:Patch :: forall t h o.
Patch' t h o -> Map (Reference' t h) (Set (TypeEdit' t o))
typeEdits} =
  H2.Patch
    { termEdits :: Map Referent (Set TermEdit)
termEdits = (Referent' Text ComponentHash -> Referent)
-> (Set (TermEdit' Text ComponentHash) -> Set TermEdit)
-> Map
     (Referent' Text ComponentHash) (Set (TermEdit' Text ComponentHash))
-> Map Referent (Set TermEdit)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Referent' Text ComponentHash -> Referent
cvreferent ((TermEdit' Text ComponentHash -> TermEdit)
-> Set (TermEdit' Text ComponentHash) -> Set TermEdit
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map TermEdit' Text ComponentHash -> TermEdit
cvTermEdit) Map
  (Referent' Text ComponentHash) (Set (TermEdit' Text ComponentHash))
termEdits,
      typeEdits :: Map Reference (Set TypeEdit)
typeEdits = (Reference' Text ComponentHash -> Reference)
-> (Set (TypeEdit' Text ComponentHash) -> Set TypeEdit)
-> Map
     (Reference' Text ComponentHash)
     (Set (TypeEdit' Text ComponentHash))
-> Map Reference (Set TypeEdit)
forall a' a b b'.
Ord a' =>
(a -> a') -> (b -> b') -> Map a b -> Map a' b'
Map.bimap Reference' Text ComponentHash -> Reference
cvreference ((TypeEdit' Text ComponentHash -> TypeEdit)
-> Set (TypeEdit' Text ComponentHash) -> Set TypeEdit
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map TypeEdit' Text ComponentHash -> TypeEdit
cvTypeEdit) Map
  (Reference' Text ComponentHash)
  (Set (TypeEdit' Text ComponentHash))
typeEdits
    }
  where
    cvTermEdit :: Memory.TermEdit.HashTermEdit -> H2.TermEdit
    cvTermEdit :: TermEdit' Text ComponentHash -> TermEdit
cvTermEdit = \case
      Memory.TermEdit.Replace Referent' Text ComponentHash
ref Typing
_typing -> Referent -> TermEdit
H2.TermEditReplace (Referent -> Referent
v2ToH2Referent (Referent -> Referent)
-> (Referent' Text ComponentHash -> Referent)
-> Referent' Text ComponentHash
-> Referent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Referent' Text ComponentHash -> Referent
forall a b. Coercible a b => a -> b
coerce (Referent' Text ComponentHash -> Referent)
-> Referent' Text ComponentHash -> Referent
forall a b. (a -> b) -> a -> b
$ Referent' Text ComponentHash
ref)
      TermEdit' Text ComponentHash
Memory.TermEdit.Deprecate -> TermEdit
H2.TermEditDeprecate
    cvTypeEdit :: Memory.TypeEdit.HashTypeEdit -> H2.TypeEdit
    cvTypeEdit :: TypeEdit' Text ComponentHash -> TypeEdit
cvTypeEdit = \case
      Memory.TypeEdit.Replace Reference' Text ComponentHash
ref -> Reference -> TypeEdit
H2.TypeEditReplace (Reference -> Reference
v2ToH2Reference (Reference -> Reference)
-> (Reference' Text ComponentHash -> Reference)
-> Reference' Text ComponentHash
-> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reference' Text ComponentHash -> Reference
forall a b. Coercible a b => a -> b
coerce (Reference' Text ComponentHash -> Reference)
-> Reference' Text ComponentHash -> Reference
forall a b. (a -> b) -> a -> b
$ Reference' Text ComponentHash
ref)
      TypeEdit' Text ComponentHash
Memory.TypeEdit.Deprecate -> TypeEdit
H2.TypeEditDeprecate
    cvreference :: V2Reference.Reference' Text ComponentHash -> H2.Reference
    cvreference :: Reference' Text ComponentHash -> Reference
cvreference = Reference -> Reference
v2ToH2Reference (Reference -> Reference)
-> (Reference' Text ComponentHash -> Reference)
-> Reference' Text ComponentHash
-> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash
    cvreferent :: Memory.BranchFull.Referent'' Text ComponentHash -> H2.Referent
    cvreferent :: Referent' Text ComponentHash -> Referent
cvreferent = \case
      V2Referent.Ref Reference' Text ComponentHash
ref -> (Reference -> Referent
H2.ReferentRef (Reference -> Reference
v2ToH2Reference (Reference -> Reference) -> Reference -> Reference
forall a b. (a -> b) -> a -> b
$ (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash Reference' Text ComponentHash
ref))
      V2Referent.Con Reference' Text ComponentHash
typeRef Pos
conId -> do
        (Reference -> Pos -> Referent
H2.ReferentCon (Reference -> Reference
v2ToH2Reference (Reference -> Reference) -> Reference -> Reference
forall a b. (a -> b) -> a -> b
$ (ComponentHash -> Hash)
-> Reference' Text ComponentHash -> Reference
forall b c a. (b -> c) -> Reference' a b -> Reference' a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ComponentHash -> Hash
unComponentHash Reference' Text ComponentHash
typeRef) Pos
conId)

v2ToH2Term :: forall v. (Ord v) => V2.Term.HashableTerm v -> H2.Term v ()
v2ToH2Term :: forall v. Ord v => HashableTerm v -> Term v ()
v2ToH2Term = (forall a1.
 F' Text Reference Reference Referent Reference v a1
 -> TermF v () () a1)
-> Term (F' Text Reference Reference Referent Reference v) v ()
-> Term (TermF v () ()) v ()
forall v (g :: * -> *) (f :: * -> *) a.
(Ord v, Foldable g, Functor g) =>
(forall a1. f a1 -> g a1) -> Term f v a -> Term g v a
ABT.transform F' Text Reference Reference Referent Reference v a1
-> TermF v () () a1
forall a1.
F' Text Reference Reference Referent Reference v a1
-> TermF v () () a1
convertF
  where
    convertF :: V2.Term.F' Text V2.Term.HashableTermRef V2.Term.TypeRef V2.Term.HashableTermLink V2.Term.TypeLink v a1 -> H2.TermF v () () a1
    convertF :: forall a1.
F' Text Reference Reference Referent Reference v a1
-> TermF v () () a1
convertF = \case
      V2.Term.Int Int64
i -> Int64 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Int64 -> TermF typeVar typeAnn patternAnn a
H2.TermInt Int64
i
      V2.Term.Nat Pos
i -> Pos -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Pos -> TermF typeVar typeAnn patternAnn a
H2.TermNat Pos
i
      V2.Term.Float Double
n -> Double -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Double -> TermF typeVar typeAnn patternAnn a
H2.TermFloat Double
n
      V2.Term.Boolean Bool
b -> Bool -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Bool -> TermF typeVar typeAnn patternAnn a
H2.TermBoolean Bool
b
      V2.Term.Text Text
t -> Text -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Text -> TermF typeVar typeAnn patternAnn a
H2.TermText Text
t
      V2.Term.Char Char
c -> Char -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Char -> TermF typeVar typeAnn patternAnn a
H2.TermChar Char
c
      V2.Term.Ref Reference
r -> Reference -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Reference -> TermF typeVar typeAnn patternAnn a
H2.TermRef (Reference -> Reference
v2ToH2Reference Reference
r)
      V2.Term.Constructor Reference
r Pos
cid -> Reference -> Pos -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Reference -> Pos -> TermF typeVar typeAnn patternAnn a
H2.TermConstructor (Reference -> Reference
v2ToH2Reference Reference
r) Pos
cid
      V2.Term.Request Reference
r Pos
cid -> Reference -> Pos -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Reference -> Pos -> TermF typeVar typeAnn patternAnn a
H2.TermRequest (Reference -> Reference
v2ToH2Reference Reference
r) Pos
cid
      V2.Term.Handle a1
a a1
b -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermHandle a1
a a1
b
      V2.Term.App a1
a a1
b -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermApp a1
a a1
b
      V2.Term.Ann a1
a TypeR Reference v
k -> a1 -> Type v () -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> Type typeVar typeAnn -> TermF typeVar typeAnn patternAnn a
H2.TermAnn a1
a (TypeR Reference v -> Type v ()
forall v. Ord v => TypeR Reference v -> Type v ()
v2ToH2Type TypeR Reference v
k)
      V2.Term.List Seq a1
a -> Seq a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Seq a -> TermF typeVar typeAnn patternAnn a
H2.TermList Seq a1
a
      V2.Term.If a1
a a1
b a1
c -> a1 -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermIf a1
a a1
b a1
c
      V2.Term.And a1
a a1
b -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermAnd a1
a a1
b
      V2.Term.Or a1
a a1
b -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermOr a1
a a1
b
      V2.Term.Lam a1
a -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> TermF typeVar typeAnn patternAnn a
H2.TermLam a1
a
      V2.Term.LetRec [a1]
as a1
b -> [a1] -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
[a] -> a -> TermF typeVar typeAnn patternAnn a
H2.TermLetRec [a1]
as a1
b
      V2.Term.Let a1
a a1
b -> a1 -> a1 -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> a -> TermF typeVar typeAnn patternAnn a
H2.TermLet a1
a a1
b
      V2.Term.Match a1
a [MatchCase Text Reference a1]
b -> a1 -> [MatchCase () a1] -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
a -> [MatchCase patternAnn a] -> TermF typeVar typeAnn patternAnn a
H2.TermMatch a1
a ((MatchCase Text Reference a1 -> MatchCase () a1)
-> [MatchCase Text Reference a1] -> [MatchCase () a1]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MatchCase Text Reference a1 -> MatchCase () a1
forall x. MatchCase Text Reference x -> MatchCase () x
convertMatchCase [MatchCase Text Reference a1]
b)
      V2.Term.TermLink Referent
a -> Referent -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Referent -> TermF typeVar typeAnn patternAnn a
H2.TermTermLink (Referent -> Referent
v2ToH2Referent Referent
a)
      V2.Term.TypeLink Reference
a -> Reference -> TermF v () () a1
forall typeVar typeAnn patternAnn a.
Reference -> TermF typeVar typeAnn patternAnn a
H2.TermTypeLink (Reference -> Reference
v2ToH2Reference Reference
a)

    convertMatchCase :: forall x. V2.Term.MatchCase Text V2.Term.TypeRef x -> H2.MatchCase () x
    convertMatchCase :: forall x. MatchCase Text Reference x -> MatchCase () x
convertMatchCase (V2.Term.MatchCase Pattern Text Reference
pat Maybe x
guard x
body) =
      Pattern () -> Maybe x -> x -> MatchCase () x
forall loc a. Pattern loc -> Maybe a -> a -> MatchCase loc a
H2.MatchCase (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
pat) Maybe x
guard x
body

    convertPattern :: V2.Term.Pattern Text V2.Term.TypeRef -> H2.Pattern ()
    convertPattern :: Pattern Text Reference -> Pattern ()
convertPattern = \case
      Pattern Text Reference
V2.Term.PUnbound -> () -> Pattern ()
forall loc. loc -> Pattern loc
H2.PatternUnbound ()
      Pattern Text Reference
V2.Term.PVar -> () -> Pattern ()
forall loc. loc -> Pattern loc
H2.PatternVar ()
      V2.Term.PBoolean Bool
b -> () -> Bool -> Pattern ()
forall loc. loc -> Bool -> Pattern loc
H2.PatternBoolean () Bool
b
      V2.Term.PInt Int64
i -> () -> Int64 -> Pattern ()
forall loc. loc -> Int64 -> Pattern loc
H2.PatternInt () Int64
i
      V2.Term.PNat Pos
i -> () -> Pos -> Pattern ()
forall loc. loc -> Pos -> Pattern loc
H2.PatternNat () Pos
i
      V2.Term.PFloat Double
n -> () -> Double -> Pattern ()
forall loc. loc -> Double -> Pattern loc
H2.PatternFloat () Double
n
      V2.Term.PText Text
t -> () -> Text -> Pattern ()
forall loc. loc -> Text -> Pattern loc
H2.PatternText () Text
t
      V2.Term.PChar Char
c -> () -> Char -> Pattern ()
forall loc. loc -> Char -> Pattern loc
H2.PatternChar () Char
c
      V2.Term.PConstructor Reference
r Pos
cid [Pattern Text Reference]
ps -> () -> Reference -> Pos -> [Pattern ()] -> Pattern ()
forall loc. loc -> Reference -> Pos -> [Pattern loc] -> Pattern loc
H2.PatternConstructor () (Reference -> Reference
v2ToH2Reference Reference
r) Pos
cid (Pattern Text Reference -> Pattern ()
convertPattern (Pattern Text Reference -> Pattern ())
-> [Pattern Text Reference] -> [Pattern ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern Text Reference]
ps)
      V2.Term.PAs Pattern Text Reference
pat -> () -> Pattern () -> Pattern ()
forall loc. loc -> Pattern loc -> Pattern loc
H2.PatternAs () (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
pat)
      V2.Term.PEffectPure Pattern Text Reference
pat -> () -> Pattern () -> Pattern ()
forall loc. loc -> Pattern loc -> Pattern loc
H2.PatternEffectPure () (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
pat)
      V2.Term.PEffectBind Reference
r Pos
conId [Pattern Text Reference]
pats Pattern Text Reference
pat -> () -> Reference -> Pos -> [Pattern ()] -> Pattern () -> Pattern ()
forall loc.
loc
-> Reference -> Pos -> [Pattern loc] -> Pattern loc -> Pattern loc
H2.PatternEffectBind () (Reference -> Reference
v2ToH2Reference Reference
r) Pos
conId (Pattern Text Reference -> Pattern ()
convertPattern (Pattern Text Reference -> Pattern ())
-> [Pattern Text Reference] -> [Pattern ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern Text Reference]
pats) (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
pat)
      V2.Term.PSequenceLiteral [Pattern Text Reference]
pats -> () -> [Pattern ()] -> Pattern ()
forall loc. loc -> [Pattern loc] -> Pattern loc
H2.PatternSequenceLiteral () (Pattern Text Reference -> Pattern ()
convertPattern (Pattern Text Reference -> Pattern ())
-> [Pattern Text Reference] -> [Pattern ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern Text Reference]
pats)
      V2.Term.PSequenceOp Pattern Text Reference
l SeqOp
op Pattern Text Reference
r -> () -> Pattern () -> SeqOp -> Pattern () -> Pattern ()
forall loc.
loc -> Pattern loc -> SeqOp -> Pattern loc -> Pattern loc
H2.PatternSequenceOp () (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
l) (SeqOp -> SeqOp
convertSequenceOp SeqOp
op) (Pattern Text Reference -> Pattern ()
convertPattern Pattern Text Reference
r)

    convertSequenceOp :: V2.Term.SeqOp -> H2.SeqOp
    convertSequenceOp :: SeqOp -> SeqOp
convertSequenceOp = \case
      SeqOp
V2.Term.PCons -> SeqOp
H2.Cons
      SeqOp
V2.Term.PSnoc -> SeqOp
H2.Snoc
      SeqOp
V2.Term.PConcat -> SeqOp
H2.Concat

v2ToH2Decl :: V2.Decl.HashableDecl Unison.Symbol -> H2.Decl Unison.Symbol ()
v2ToH2Decl :: HashableDecl Symbol -> Decl Symbol ()
v2ToH2Decl (V2.Decl.DataDeclaration {DeclType
declType :: DeclType
$sel:declType:DataDeclaration :: forall r v. DeclR r v -> DeclType
declType, Modifier
modifier :: Modifier
$sel:modifier:DataDeclaration :: forall r v. DeclR r v -> Modifier
modifier, [Symbol]
bound :: [Symbol]
$sel:bound:DataDeclaration :: forall r v. DeclR r v -> [v]
bound, [TypeR Reference Symbol]
constructorTypes :: [TypeR Reference Symbol]
$sel:constructorTypes:DataDeclaration :: forall r v. DeclR r v -> [TypeR r v]
constructorTypes}) =
  let tag :: DataDeclaration v a
-> Either (EffectDeclaration v a) (DataDeclaration v a)
tag = case DeclType
declType of
        DeclType
V2.Decl.Effect -> EffectDeclaration v a
-> Either (EffectDeclaration v a) (DataDeclaration v a)
forall a b. a -> Either a b
Left (EffectDeclaration v a
 -> Either (EffectDeclaration v a) (DataDeclaration v a))
-> (DataDeclaration v a -> EffectDeclaration v a)
-> DataDeclaration v a
-> Either (EffectDeclaration v a) (DataDeclaration v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataDeclaration v a -> EffectDeclaration v a
forall v a. DataDeclaration v a -> EffectDeclaration v a
H2.EffectDeclaration
        DeclType
V2.Decl.Data -> DataDeclaration v a
-> Either (EffectDeclaration v a) (DataDeclaration v a)
forall a b. b -> Either a b
Right
   in DataDeclaration Symbol () -> Decl Symbol ()
forall {v} {a}.
DataDeclaration v a
-> Either (EffectDeclaration v a) (DataDeclaration v a)
tag (DataDeclaration Symbol () -> Decl Symbol ())
-> DataDeclaration Symbol () -> Decl Symbol ()
forall a b. (a -> b) -> a -> b
$
        H2.DataDeclaration
          { modifier :: Modifier
modifier = Modifier -> Modifier
v2ToH2Modifier Modifier
modifier,
            annotation :: ()
annotation = (),
            bound :: [Symbol]
bound = [Symbol]
bound,
            constructors' :: [((), Symbol, Type Symbol ())]
constructors' =
              [TypeR Reference Symbol]
constructorTypes
                [TypeR Reference Symbol]
-> ([TypeR Reference Symbol] -> [(Int, TypeR Reference Symbol)])
-> [(Int, TypeR Reference Symbol)]
forall a b. a -> (a -> b) -> b
& [Int]
-> [TypeR Reference Symbol] -> [(Int, TypeR Reference Symbol)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..]
                [(Int, TypeR Reference Symbol)]
-> ([(Int, TypeR Reference Symbol)]
    -> [((), Symbol, Type Symbol ())])
-> [((), Symbol, Type Symbol ())]
forall a b. a -> (a -> b) -> b
& ((Int, TypeR Reference Symbol) -> ((), Symbol, Type Symbol ()))
-> [(Int, TypeR Reference Symbol)]
-> [((), Symbol, Type Symbol ())]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int, TypeR Reference Symbol) -> ((), Symbol, Type Symbol ())
mkCtor
          }
  where
    mkCtor :: (Int, V2.Type.TypeR V2.Decl.HashableTypeRef Unison.Symbol) -> ((), Unison.Symbol, H2.Type Unison.Symbol ())
    mkCtor :: (Int, TypeR Reference Symbol) -> ((), Symbol, Type Symbol ())
mkCtor (Int
n, TypeR Reference Symbol
t) = ((), Text -> Symbol
Unison.symbol (Text -> Symbol) -> ([Char] -> Text) -> [Char] -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
Text.pack ([Char] -> Symbol) -> [Char] -> Symbol
forall a b. (a -> b) -> a -> b
$ [Char]
"Constructor" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n, TypeR Reference Symbol -> Type Symbol ()
forall v. Ord v => TypeR Reference v -> Type v ()
v2ToH2Type TypeR Reference Symbol
t)

    v2ToH2Modifier :: V2.Decl.Modifier -> H2.Modifier
    v2ToH2Modifier :: Modifier -> Modifier
v2ToH2Modifier = \case
      Modifier
V2.Decl.Structural -> Modifier
H2.Structural
      V2.Decl.Unique Text
t -> Text -> Modifier
H2.Unique Text
t