diff --git a/ci/da-ghc-lib/compile.yml b/ci/da-ghc-lib/compile.yml index 5e316193cd..01ddd05e34 100644 --- a/ci/da-ghc-lib/compile.yml +++ b/ci/da-ghc-lib/compile.yml @@ -12,7 +12,7 @@ jobs: variables: ghc-lib-sha: '42e5c306dcfbc84b83336fdd531023e93bfcc5b2' base-sha: '9c787d4d24f2b515934c8503ee2bbd7cfac4da20' - patches: '71fbb2da5199d7f96b943f133d03ff72252fbcbf 833ca63be2ab14871874ccb6974921e8952802e9' + patches: '65f50a6f72097324de23d6168e3cb9efe734c181 833ca63be2ab14871874ccb6974921e8952802e9' flavor: 'ghc-8.8.1' steps: - checkout: self diff --git a/compiler/damlc/daml-lf-conversion/src/DA/Daml/LFConversion.hs b/compiler/damlc/daml-lf-conversion/src/DA/Daml/LFConversion.hs index 10488c7df1..358b245796 100644 --- a/compiler/damlc/daml-lf-conversion/src/DA/Daml/LFConversion.hs +++ b/compiler/damlc/daml-lf-conversion/src/DA/Daml/LFConversion.hs @@ -177,7 +177,8 @@ data Env = Env ,envExceptionBinds :: MS.Map TypeConName ExceptionBinds ,envChoiceData :: MS.Map TypeConName [ChoiceData] ,envImplements :: MS.Map TypeConName [GHC.TyCon] - ,envInterfaceInstances :: MS.Map (GHC.Module, TypeConName, TypeConName) (GHC.Expr GHC.CoreBndr) + ,envInterfaceMethodInstances :: MS.Map (GHC.Module, TypeConName, TypeConName) [(T.Text, GHC.Expr GHC.CoreBndr)] + ,envEmptyInterfaces :: S.Set (GHC.Module, TypeConName) ,envInterfaceChoiceData :: MS.Map TypeConName [ChoiceData] ,envInterfaces :: MS.Map TypeConName GHC.TyCon ,envIsGenerated :: Bool @@ -435,41 +436,50 @@ interfaceNames lfVersion tyThings ] | otherwise = MS.empty -convertInterfaces :: Env -> [TyThing] -> ConvertM [Definition] -convertInterfaces env tyThings = interfaceClasses +convertInterfaces :: Env -> [(Var, GHC.Expr Var)] -> ConvertM [Definition] +convertInterfaces env binds = interfaceDefs where - interfaceClasses :: ConvertM [Definition] - interfaceClasses = sequence - [ DInterface <$> convertInterface name tycon cls - | ATyCon t <- tyThings - , Just cls <- [tyConClass_maybe t] - , Just interface <- [T.stripPrefix "Is" (getOccText t)] - , let name = TypeConName [interface] - , Just tycon <- [MS.lookup name (envInterfaces env)] - ] + interfaceDefs :: ConvertM [Definition] + interfaceDefs = sequence + [ DInterface <$> convertInterface name tycon + | (name, val) <- binds + -- We're looking for `instance DA.Internal.Desugar.Implements I I` + , DFunId _ <- [idDetails name] + , TypeCon implementsCls [TypeCon tpl [], TypeCon ifc []] <- [varType name] + , NameIn DA_Internal_Desugar "Implements" <- [implementsCls] + , tpl == ifc + , let name = TypeConName [getOccText ifc] + tycon = ifc + ] - convertInterface :: LF.TypeConName -> GHC.TyCon -> Class -> ConvertM DefInterface - convertInterface intName tyCon cls = do + convertInterface :: LF.TypeConName -> GHC.TyCon -> ConvertM DefInterface + convertInterface intName tyCon = do let intLocation = convNameLoc (GHC.tyConName tyCon) let intParam = this let precond = fromMaybe (error $ "Missing precondition for interface " <> show intName) $ (MS.lookup intName $ envInterfaceBinds env) >>= ibEnsure withRange intLocation $ do - intMethods <- NM.fromList <$> mapM convertMethod (drop 4 $ classMethods cls) + intMethods <- NM.fromList <$> convertMethods tyCon intFixedChoices <- convertChoices env intName emptyTemplateBinds intPrecondition <- useSingleMethodDict env precond (`ETmApp` EVar intParam) pure DefInterface {..} - convertMethod :: Var -> ConvertM InterfaceMethod - convertMethod method = do - retTy <- convertType env (varType method) >>= \case - TForall _ (_dict :-> _iface :-> retTy) -> pure retTy - ty -> unsupported "Interface method must be a function" (varType method) - let methodName = occNameString (getOccName (varName method)) + convertMethods :: GHC.TyCon -> ConvertM [InterfaceMethod] + convertMethods tyCon = sequence $ do + (name, val) <- binds + DFunId _ <- [idDetails name] + TypeCon hasMethodCls + [ TypeCon ((== tyCon) -> True) [] + , StrLitTy methodName + , retTy + ] <- [varType name] + NameIn DA_Internal_Desugar "HasMethod" <- [hasMethodCls] + pure $ do + retTy' <- convertType env retTy pure InterfaceMethod { ifmLocation = Nothing - , ifmName = MethodName (T.pack methodName) - , ifmType = retTy + , ifmName = MethodName methodName + , ifmType = retTy' } convertConsuming :: LF.Type -> ConvertM Consuming @@ -497,7 +507,7 @@ convertModule lfVersion pkgMap stablePackages isGenerated file x depOrphanModule depOrphanModules <- convertDepOrphanModules env depOrphanModules templates <- convertTemplateDefs env exceptions <- convertExceptionDefs env - interfaces <- convertInterfaces env (eltsUFM (cm_types x)) + interfaces <- convertInterfaces env binds exports <- convertExports env (md_exports details) let defs = types @@ -525,20 +535,59 @@ convertModule lfVersion pkgMap stablePackages isGenerated file x depOrphanModule ] interfaceCons = interfaceNames lfVersion (eltsUFM (cm_types x)) tplImplements = MS.fromListWith (++) - [ (mkTypeCon [getOccText tplTy], [ifaceTy]) - | (name, _) <- binds - , "_implements_" `T.isPrefixOf` getOccText name - , TypeCon _ [TypeCon tplTy [], TypeCon ifaceTy []] <- [varType name] - ] - tplInterfaceInstances :: MS.Map (GHC.Module, TypeConName, TypeConName) (GHC.Expr GHC.CoreBndr) - tplInterfaceInstances = MS.fromList - [ ((mod, mkTypeCon [iface], mkTypeCon [getOccText tpl]), val) - | (name, val) <- binds - , DFunId _ <- [idDetails name] - , TypeCon ifaceCls [TypeCon tpl []] <- [varType name] - , Just iface <- [T.stripPrefix "Is" $ getOccText ifaceCls] - , Just mod <- [nameModule_maybe (getName ifaceCls)] - ] + [ (mkTypeCon [getOccText tpl], [iface]) + | (name, _val) <- binds + , DFunId _ <- [idDetails name] + , TypeCon implementsCls [TypeCon tpl [], TypeCon iface []] <- [varType name] + , NameIn DA_Internal_Desugar "Implements" <- [implementsCls] + ] + tplInterfaceMethodInstances :: MS.Map (GHC.Module, TypeConName, TypeConName) [(T.Text, GHC.Expr GHC.CoreBndr)] + tplInterfaceMethodInstances = MS.fromListWith (++) + [ + ( (mod, mkTypeCon [getOccText iface], mkTypeCon [getOccText tpl]) + , [(methodName, body)] + ) + | (name, val) <- binds + , TypeCon methodNewtype + [ TypeCon tpl [] + , TypeCon iface [] + , StrLitTy methodName + , _methodType + ] <- [varType name] + , NameIn DA_Internal_Desugar "Method" <- [methodNewtype] + , Just mod <- [nameModule_maybe (getName iface)] + , Var (NameIn DA_Internal_Desugar "mkMethod") + `App` Type _tpl + `App` Type _iface + `App` Type _methodName + `App` Type _methodType + `App` _implDict + `App` _hasMethodDict + `App` body + <- [untick val] + ] + emptyInterfaces :: S.Set (GHC.Module, TypeConName) + emptyInterfaces = S.fromList + [ (mod, mkTypeCon [getOccText ifc]) + | (name, val) <- binds + -- We're looking for `instance DA.Internal.Desugar.Implements I I` + , DFunId _ <- [idDetails name] + , TypeCon implementsCls [TypeCon tpl [], TypeCon ifc []] <- [varType name] + , NameIn DA_Internal_Desugar "Implements" <- [implementsCls] + , Just mod <- [nameModule_maybe (getName ifc)] + , tpl == ifc + -- such that there are no `instance HasMethod I _ _` + , null + [ () + | (name, val) <- binds + , DFunId _ <- [idDetails name] + , TypeCon hasMethodCls + [ TypeCon ((== ifc) -> True) [] + , _ + , _ + ] <- [varType name] + ] + ] choiceData = MS.fromListWith (++) [ (mkTypeCon [getOccText tplTy], [ChoiceData ty v]) | (name, v) <- binds @@ -573,7 +622,8 @@ convertModule lfVersion pkgMap stablePackages isGenerated file x depOrphanModule , envInterfaceBinds = interfaceBinds , envExceptionBinds = exceptionBinds , envImplements = tplImplements - , envInterfaceInstances = tplInterfaceInstances + , envInterfaceMethodInstances = tplInterfaceMethodInstances + , envEmptyInterfaces = emptyInterfaces , envChoiceData = choiceData , envIsGenerated = isGenerated , envTypeVars = MS.empty @@ -951,31 +1001,29 @@ useSingleMethodDict env x _ = unhandled "useSingleMethodDict: not a single method type class dictionary" x convertImplements :: Env -> LF.TypeConName -> ConvertM (NM.NameMap TemplateImplements) -convertImplements env tplTypeCon = NM.fromList <$> - mapM convertInterface (MS.findWithDefault [] tplTypeCon (envImplements env)) +convertImplements env tpl = NM.fromList <$> + mapM convertInterface (MS.findWithDefault [] tpl (envImplements env)) where - convertInterface ty = do - ty' <- convertTyCon env ty - con <- case ty' of - TCon con -> pure con - _ -> unhandled "interface type" ty - let mod = nameModule (getName ty) - dictExpr <- case MS.lookup (mod, qualObject con, tplTypeCon) (envInterfaceInstances env) of - Just e -> pure e - Nothing -> unhandled ("missing interface instance for " <> show con) () - fields <- convertExpr env dictExpr >>= \case - EStructCon fields -> pure fields - e -> unhandled ("Expected struct for interface dict but got " <> show e) () - -- Drop superclass constraints and to/fromIface & to/fromIfaceContractId - -- which are always at the beginning. - let methodFields = drop 4 (filter (\(FieldName f, _) -> "m_" `T.isPrefixOf` f) fields) - let methods = NM.fromList - [ TemplateImplementsMethod (MethodName methodName) e - | (FieldName fieldName, e) <- methodFields - , Just methodName <- [T.stripPrefix "m_" fieldName] - ] - let inheritedChoiceNames = S.empty -- This is filled during LF post-processing (in the LF completer). - pure (TemplateImplements con methods inheritedChoiceNames) + convertInterface iface = do + iface' <- convertTyCon env iface + con <- case iface' of + TCon con -> pure con + _ -> unhandled "interface type" iface + let mod = nameModule (getName iface) + + methods <- if S.member (mod, qualObject con) (envEmptyInterfaces env) + then pure NM.empty + else case MS.lookup (mod, qualObject con, tpl) (envInterfaceMethodInstances env) of + Just ms -> convertMethods ms + Nothing -> unhandled ("missing interface instance for " <> show (con, tpl)) () + + let inheritedChoiceNames = S.empty -- This is filled during LF post-processing (in the LF completer). + pure (TemplateImplements con methods inheritedChoiceNames) + + convertMethods ms = fmap NM.fromList . sequence $ + [ TemplateImplementsMethod (MethodName k) <$> convertExpr env v + | (k, v) <- ms + ] convertChoices :: Env -> LF.TypeConName -> TemplateBinds -> ConvertM (NM.NameMap TemplateChoice) convertChoices env tplTypeCon tbinds = @@ -1042,6 +1090,9 @@ convertBind env (name, x) -- These are only used as markers for the LF conversion. | "_implements_" `T.isPrefixOf` getOccText name = pure [] + -- These are moved into interface implementations so we can drop them + | "_method_" `T.isPrefixOf` getOccText name + = pure [] -- Remove internal functions. | Just internals <- lookupUFM internalFunctions (envGHCModuleName env) @@ -1092,6 +1143,12 @@ convertBind env (name, x) | ConstraintTupleProjectionName _ _ <- name = pure [] + -- HasMethod instances are only used for desugaring. + | DFunId _ <- idDetails name + , TypeCon hasMethodCls _ <- varType name + , NameIn DA_Internal_Desugar "HasMethod" <- hasMethodCls + = pure [] + -- Typeclass instance dictionaries | DFunId isNewtype <- idDetails name = withRange (convNameLoc name) $ do @@ -1137,7 +1194,14 @@ internalTypes = mkUniqSet ] desugarTypes :: UniqSet FastString -desugarTypes = mkUniqSet ["Consuming", "PreConsuming", "PostConsuming", "NonConsuming", "Implements"] +desugarTypes = mkUniqSet + [ "Consuming" + , "PreConsuming" + , "PostConsuming" + , "NonConsuming" + , "Method" + , "HasMethod" + ] internalFunctions :: UniqFM (UniqSet FastString) internalFunctions = listToUFM $ map (bimap mkModuleNameFS mkUniqSet) @@ -1149,6 +1213,10 @@ internalFunctions = listToUFM $ map (bimap mkModuleNameFS mkUniqSet) , ("GHC.Base", [ "getTag" ]) + , ("DA.Internal.Desugar", + [ "mkMethod" + , "$sel:unMethod:Method" + ]) ] convertExpr :: Env -> GHC.Expr Var -> ConvertM LF.Expr diff --git a/compiler/damlc/daml-stdlib-src/DA/Internal/Desugar.daml b/compiler/damlc/daml-stdlib-src/DA/Internal/Desugar.daml index 047418f638..c6f250a01f 100644 --- a/compiler/damlc/daml-stdlib-src/DA/Internal/Desugar.daml +++ b/compiler/damlc/daml-stdlib-src/DA/Internal/Desugar.daml @@ -2,6 +2,7 @@ -- SPDX-License-Identifier: Apache-2.0 {-# LANGUAGE CPP #-} +{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE NoImplicitPrelude #-} @@ -17,6 +18,8 @@ module DA.Internal.Desugar ( NonConsuming(..), PreConsuming(..), PostConsuming(..), Consuming(..), Implements(..), TypeRep, + HasMethod, + mkMethod, ) where import DA.Internal.Prelude @@ -28,11 +31,66 @@ import DA.Internal.Exception () #else import DA.Internal.Exception #endif -import GHC.Types (magic) +import GHC.Types (magic, Symbol) -- These are only used as markers by desugaring, we do not translate them to LF. data NonConsuming t = NonConsuming {} data PreConsuming t = PreConsuming {} data Consuming t = Consuming {} data PostConsuming t = PostConsuming {} -data Implements t i = Implements + +class Implements t i where + toInterface : t -> i + fromInterface : i -> Optional t + toInterfaceContractId : ContractId t -> ContractId i + fromInterfaceContractId : ContractId i -> Update (Optional (ContractId t)) + interfaceTypeRep : t -> TypeRep + +{- +Together, `HasMethod`, `Method` and `mkMethod` allow us to desugar the methods of +an interface implementation in `RdrHsSyn`, while ensuring that all implementations +have the same type. + +Given + +> interface Iface where +> myMethod : MyMethodType + +`RdrHsSyn` generates this instance of `HasMethod` + +> instance HasMethod Iface "myMethod" MyMethodType + +Meanwhile, given + +> template Tplt +> with +> ... +> where +> ... +> implements Iface where +> let myMethod = myMethodImpl this + +`RdrHsSyn` generates the following binding + +> _method_Tplt_Iface_myMethod = mkMethod @Tplt @Iface @"myMethod" (\this -> myMethodImpl this) + +Note that `RdrHsSyn` cannot give a type signature to `_method_Tplt_Iface_myMethod`, since +the type of the method is not available in the `implements` block. + +Then how can we ensure that all implementations of that method have the right type? +By wrapping the method implementation in the `Method t i m r` type using the +`mkMethod` function with the necessary type applications, we bind the first three +type variables `t i m` to the template, interface and method name types, respectively. +Then, the functional dependency `i m -> r` in the `HasMethod` class guarantees +that for the given interface type and method name, the return type `r` is fixed. +Finally, the compiler has to unify the argument to `mkMethod` with the type +`t -> r`, guaranteeing that all implementations have the correct type. +-} + +-- Read: Interface `i` has a method named `m` with return type `r` +class HasMethod i (m : Symbol) r | i m -> r + +newtype Method t i (m : Symbol) r = Method { unMethod : t -> r } + +mkMethod : (Implements t i, HasMethod i m r) => (t -> r) -> Method t i m r +mkMethod = Method diff --git a/compiler/damlc/daml-stdlib-src/Prelude.daml b/compiler/damlc/daml-stdlib-src/Prelude.daml index a4e2ef60ed..a7e8db1d75 100644 --- a/compiler/damlc/daml-stdlib-src/Prelude.daml +++ b/compiler/damlc/daml-stdlib-src/Prelude.daml @@ -25,3 +25,4 @@ import DA.Internal.Template.Functions as X #endif import DA.Internal.Compatible as X import DA.Internal.Assert as X +import DA.Internal.Desugar as X (Implements (..)) diff --git a/compiler/damlc/tests/daml-test-files/Interface.daml b/compiler/damlc/tests/daml-test-files/Interface.daml index 410db22e0a..19974fae1e 100644 --- a/compiler/damlc/tests/daml-test-files/Interface.daml +++ b/compiler/damlc/tests/daml-test-files/Interface.daml @@ -57,7 +57,7 @@ template Asset implements Token where let getOwner = owner let getAmount = amount - let setAmount = \x -> toToken (this with amount = x) + let setAmount = \x -> toInterface @_ @Token (this with amount = x) -- TODO https://github.com/digital-asset/daml/issues/10810 -- (maybe) support `let setAmount x = ...` syntax. @@ -65,11 +65,11 @@ template Asset assert (splitAmount < amount) cid1 <- create this with amount = splitAmount cid2 <- create this with amount = amount - splitAmount - pure (toTokenContractId cid1, toTokenContractId cid2) + pure (toInterfaceContractId @_ @Token cid1, toInterfaceContractId @_ @Token cid2) let transferImpl = \newOwner -> do cid <- create this with owner = newOwner - pure (toTokenContractId cid) + pure (toInterfaceContractId @_ @Token cid) let noopImpl = \nothing -> do pure () @@ -86,18 +86,18 @@ main = scenario do issuer = p owner = p amount = 15 - let cidToken1 = toTokenContractId cidAsset1 + let cidToken1 = toInterfaceContractId @_ @Token cidAsset1 _ <- exercise cidToken1 (Noop ()) (cidToken2, cidToken3) <- exercise cidToken1 (Split 10) token2 <- fetch cidToken2 getAmount token2 === 10 - case fromToken token2 of + case fromInterface @_ @Token token2 of None -> abort "expected Asset" Some Asset {amount} -> amount === 10 token3 <- fetch cidToken3 getAmount token3 === 5 - case fromToken token3 of + case fromInterface @_ @Token token3 of None -> abort "expected Asset" Some Asset {amount} -> amount === 5 @@ -105,7 +105,7 @@ main = scenario do cidToken4 <- exercise cidToken3 (GetRich 20) token4 <- fetch cidToken4 getAmount token4 === 25 - case fromToken token4 of + case fromInterface @_ @Token token4 of None -> abort "expected Asset" Some Asset {amount} -> amount === 25 diff --git a/compiler/damlc/tests/daml-test-files/InterfaceConversions.daml b/compiler/damlc/tests/daml-test-files/InterfaceConversions.daml index 95d8cfa19e..a0389c8d99 100644 --- a/compiler/damlc/tests/daml-test-files/InterfaceConversions.daml +++ b/compiler/damlc/tests/daml-test-files/InterfaceConversions.daml @@ -30,23 +30,23 @@ main = scenario do p <- getParty "Alice" let template1 = Template1 p 10 template2 = Template2 p "Hi" - iface1 = toIface template1 - iface2 = toIface template2 - fromIface @Template1 iface1 === Some template1 - fromIface @Template2 iface1 === None - fromIface @Template1 iface2 === None - fromIface @Template2 iface2 === Some template2 + iface1 = toInterface @_ @Iface template1 + iface2 = toInterface @_ @Iface template2 + fromInterface @Template1 iface1 === Some template1 + fromInterface @Template2 iface1 === None + fromInterface @Template1 iface2 === None + fromInterface @Template2 iface2 === Some template2 p `submit` do templateCid1 <- create template1 templateCid2 <- create template2 - let ifaceCid1 = toIfaceContractId templateCid1 - ifaceCid2 = toIfaceContractId templateCid2 + let ifaceCid1 = toInterfaceContractId @_ @Iface templateCid1 + ifaceCid2 = toInterfaceContractId @_ @Iface templateCid2 - x1 <- fromIfaceContractId @Template1 ifaceCid1 - x2 <- fromIfaceContractId @Template2 ifaceCid1 - x3 <- fromIfaceContractId @Template1 ifaceCid2 - x4 <- fromIfaceContractId @Template2 ifaceCid2 + x1 <- fromInterfaceContractId @Template1 ifaceCid1 + x2 <- fromInterfaceContractId @Template2 ifaceCid1 + x3 <- fromInterfaceContractId @Template1 ifaceCid2 + x4 <- fromInterfaceContractId @Template2 ifaceCid2 x1 === Some templateCid1 x2 === None diff --git a/compiler/damlc/tests/daml-test-files/InterfaceDesugared.daml b/compiler/damlc/tests/daml-test-files/InterfaceDesugared.daml index 7d98b43ba4..11026bfb2c 100644 --- a/compiler/damlc/tests/daml-test-files/InterfaceDesugared.daml +++ b/compiler/damlc/tests/daml-test-files/InterfaceDesugared.daml @@ -7,84 +7,187 @@ -- | The "desugared" counterpart to Interface.daml -- Please keep in sync with Interface.daml +-- You can compare this file with the output of +-- > bazel run damlc -- compile $REPO/compiler/damlc/tests/daml-test-files/Interface.daml --target=1.dev --ghc-option=-ddump-parsed > desugared.out module InterfaceDesugared where -import DA.Assert ((===)) -import DA.Action (unless) +-- import (implicit) qualified DA.Internal.Record +-- import (implicit) qualified GHC.Types +-- import (implicit) qualified DA.Internal.Desugar +-- import (implicit) DA.Internal.RebindableSyntax +import DA.Assert ( (===) ) data GHC.Types.DamlInterface => Token = Token GHC.Types.Opaque -class IsToken t where - toToken : t -> Token - fromToken : Token -> Optional t - toTokenContractId : ContractId t -> ContractId Token - fromTokenContractId : ContractId Token -> Update (Optional (ContractId t)) - tokenTypeRep : t -> DA.Internal.Desugar.TypeRep - getOwner : t -> Party - getAmount : t -> Int - setAmount : t -> Int -> Token - splitImpl : t -> Int -> Update (ContractId Token, ContractId Token) - transferImpl : t -> Party -> Update (ContractId Token) - noopImpl : t -> () -> Update () +instance DA.Internal.Desugar.Implements Token Token where + toInterface = GHC.Types.primitive @"EToInterface" + fromInterface = GHC.Types.primitive @"EFromInterface" + toInterfaceContractId + = GHC.Types.primitive @"EToInterfaceContractId" + fromInterfaceContractId + = GHC.Types.primitive @"UFromInterfaceContractId" + interfaceTypeRep = GHC.Types.primitive @"$TO_TYPE_REP" -instance HasCreate Token where - create = GHC.Types.primitive @"UCreateInterface" -instance HasObserver Token where - observer = GHC.Types.primitive @"EObserverInterface" -instance HasSignatory Token where - signatory = GHC.Types.primitive @"ESignatoryInterface" - -instance HasFetch Token where +instance DA.Internal.Desugar.HasFetch Token where fetch = GHC.Types.primitive @"UFetchInterface" +instance DA.Internal.Desugar.HasMethod Token "noopImpl" (() + -> Update ()) +noopImpl : + DA.Internal.Desugar.Implements t Token => t -> () -> Update () +noopImpl t + = GHC.Types.primitiveInterface + @"noopImpl" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasMethod Token "transferImpl" (Party + -> Update (ContractId Token)) +transferImpl : + DA.Internal.Desugar.Implements t Token => + t -> Party -> Update (ContractId Token) +transferImpl t + = GHC.Types.primitiveInterface + @"transferImpl" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasMethod Token "splitImpl" (Int + -> Update (ContractId Token, + ContractId Token)) +splitImpl : + DA.Internal.Desugar.Implements t Token => + t -> Int -> Update (ContractId Token, ContractId Token) +splitImpl t + = GHC.Types.primitiveInterface + @"splitImpl" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasMethod Token "setAmount" (Int + -> Token) +setAmount : + DA.Internal.Desugar.Implements t Token => t -> Int -> Token +setAmount t + = GHC.Types.primitiveInterface + @"setAmount" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasMethod Token "getAmount" (Int) +getAmount : DA.Internal.Desugar.Implements t Token => t -> Int +getAmount t + = GHC.Types.primitiveInterface + @"getAmount" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasMethod Token "getOwner" (Party) +getOwner : DA.Internal.Desugar.Implements t Token => t -> Party +getOwner t + = GHC.Types.primitiveInterface + @"getOwner" (DA.Internal.Desugar.toInterface @_ @Token t) + +instance DA.Internal.Desugar.HasToAnyTemplate Token where + _toAnyTemplate = GHC.Types.primitive @"EToAnyTemplate" +instance DA.Internal.Desugar.HasFromAnyTemplate Token where + _fromAnyTemplate = GHC.Types.primitive @"EFromAnyTemplate" +instance DA.Internal.Desugar.HasTemplateTypeRep Token where + _templateTypeRep = GHC.Types.primitive @"ETemplateTypeRep" +instance DA.Internal.Desugar.HasSignatory Token where + signatory = GHC.Types.primitive @"ESignatoryInterface" +instance DA.Internal.Desugar.HasObserver Token where + observer = GHC.Types.primitive @"EObserverInterface" +instance DA.Internal.Desugar.HasCreate Token where + create = GHC.Types.primitive @"UCreateInterface" instance DA.Internal.Desugar.HasEnsure Token where - ensure this - = DA.Internal.Desugar.True - where - _ = this + ensure this = (getAmount this >= 0) -instance IsToken Token where - toToken = GHC.Types.primitive @"EToInterface" - fromToken = GHC.Types.primitive @"EFromInterface" - toTokenContractId = GHC.Types.primitive @"EToInterfaceContractId" - fromTokenContractId = GHC.Types.primitive @"UFromInterfaceContractId" - tokenTypeRep = GHC.Types.primitive @"$TO_TYPE_REP" - getOwner = GHC.Types.primitiveInterface @"getOwner" - getAmount = GHC.Types.primitiveInterface @"getAmount" - setAmount = GHC.Types.primitiveInterface @"setAmount" - noopImpl = GHC.Types.primitiveInterface @"noopImpl" - transferImpl = GHC.Types.primitiveInterface @"transferImpl" - splitImpl = GHC.Types.primitiveInterface @"splitImpl" - -data GetRich = GetRich { byHowMuch : Int } -_choice_TokenGetRich : - ( Token -> GetRich -> [DA.Internal.Desugar.Party] - , DA.Internal.Desugar.ContractId Token -> Token -> GetRich -> DA.Internal.Desugar.Update (ContractId Token) - , DA.Internal.Desugar.Consuming Token - , DA.Internal.Desugar.Optional (Token -> GetRich -> [DA.Internal.Desugar.Party]) - ) -_choice_TokenGetRich = - ( \this _ -> [getOwner this] - , \self this GetRich{byHowMuch} -> do - assert (byHowMuch > 0) - create $ setAmount this (getAmount this + byHowMuch) - , DA.Internal.Desugar.Consuming - , DA.Internal.Desugar.None - ) -instance IsToken t => HasExercise t GetRich (ContractId Token) where - exercise cid = GHC.Types.primitive @"UExerciseInterface" (toTokenContractId cid) -instance IsToken t => HasToAnyChoice t GetRich (ContractId Token) where +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasToAnyChoice t GetRich (ContractId Token) where _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" -instance IsToken t => HasFromAnyChoice t GetRich (ContractId Token) where +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasFromAnyChoice t GetRich (ContractId Token) where _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasExercise t GetRich (ContractId Token) where + exercise cid + = GHC.Types.primitive + @"UExerciseInterface" + (DA.Internal.Desugar.toInterfaceContractId @t @Token cid) + +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasToAnyChoice t Noop (()) where + _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasFromAnyChoice t Noop (()) where + _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasExercise t Noop (()) where + exercise cid + = GHC.Types.primitive + @"UExerciseInterface" + (DA.Internal.Desugar.toInterfaceContractId @t @Token cid) + +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasToAnyChoice t Transfer (ContractId Token) where + _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasFromAnyChoice t Transfer (ContractId Token) where + _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasExercise t Transfer (ContractId Token) where + exercise cid + = GHC.Types.primitive + @"UExerciseInterface" + (DA.Internal.Desugar.toInterfaceContractId @t @Token cid) + +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasToAnyChoice t Split ((ContractId Token, + ContractId Token)) where + _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasFromAnyChoice t Split ((ContractId Token, + ContractId Token)) where + _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" +instance (DA.Internal.Desugar.Implements t Token) => + DA.Internal.Desugar.HasExercise t Split ((ContractId Token, + ContractId Token)) where + exercise cid + = GHC.Types.primitive + @"UExerciseInterface" + (DA.Internal.Desugar.toInterfaceContractId @t @Token cid) + +data GHC.Types.DamlTemplate => GetRich + = GetRich {byHowMuch : Int} + +data GHC.Types.DamlTemplate => Noop + = Noop {nothing : ()} + +data GHC.Types.DamlTemplate => Transfer + = Transfer {newOwner : Party} + +data GHC.Types.DamlTemplate => Split + = Split {splitAmount : Int} + +_choice_TokenGetRich : + (Token -> GetRich -> [DA.Internal.Desugar.Party], + DA.Internal.Desugar.ContractId Token + -> Token + -> GetRich -> DA.Internal.Desugar.Update (ContractId Token), + DA.Internal.Desugar.Consuming Token, + DA.Internal.Desugar.Optional (Token + -> GetRich -> [DA.Internal.Desugar.Party])) +_choice_TokenGetRich + = (\ this arg@GetRich {..} + -> let _ = this in + let _ = arg in DA.Internal.Desugar.toParties (getOwner this), + \ self this arg@GetRich {..} + -> let _ = self in + let _ = this in + let _ = arg + in + do assert (byHowMuch > 0) + create $ setAmount this (getAmount this + byHowMuch), + DA.Internal.Desugar.Consuming, DA.Internal.Desugar.None) -data Noop = Noop { nothing : () } _choice_TokenNoop : - ( Token -> Noop -> [DA.Internal.Desugar.Party] - , DA.Internal.Desugar.ContractId Token -> Token -> Noop -> DA.Internal.Desugar.Update () - , DA.Internal.Desugar.NonConsuming Token - , DA.Internal.Desugar.Optional (Token -> Noop -> [DA.Internal.Desugar.Party]) - ) + (Token -> Noop -> [DA.Internal.Desugar.Party], + DA.Internal.Desugar.ContractId Token + -> Token -> Noop -> DA.Internal.Desugar.Update (()), + DA.Internal.Desugar.NonConsuming Token, + DA.Internal.Desugar.Optional (Token + -> Noop -> [DA.Internal.Desugar.Party])) _choice_TokenNoop = (\ this arg@Noop {..} -> let _ = this in @@ -93,20 +196,15 @@ _choice_TokenNoop -> let _ = self in let _ = this in let _ = arg in do noopImpl this nothing, DA.Internal.Desugar.NonConsuming, DA.Internal.Desugar.None) -instance (IsToken t) => HasToAnyChoice t Noop (()) where - _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" -instance (IsToken t) => HasFromAnyChoice t Noop (()) where - _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" -instance (IsToken t) => HasExercise t Noop (()) where - exercise cid = GHC.Types.primitive @"UExerciseInterface" (toTokenContractId cid) -data Transfer = Transfer { newOwner : Party } _choice_TokenTransfer : - ( Token -> Transfer -> [DA.Internal.Desugar.Party] - , DA.Internal.Desugar.ContractId Token -> Token -> Transfer -> DA.Internal.Desugar.Update (ContractId Token) - , DA.Internal.Desugar.Consuming Token - , DA.Internal.Desugar.Optional (Token -> Transfer -> [DA.Internal.Desugar.Party]) - ) + (Token -> Transfer -> [DA.Internal.Desugar.Party], + DA.Internal.Desugar.ContractId Token + -> Token + -> Transfer -> DA.Internal.Desugar.Update (ContractId Token), + DA.Internal.Desugar.Consuming Token, + DA.Internal.Desugar.Optional (Token + -> Transfer -> [DA.Internal.Desugar.Party])) _choice_TokenTransfer = (\ this arg@Transfer {..} -> let _ = this in @@ -119,20 +217,17 @@ _choice_TokenTransfer -> let _ = self in let _ = this in let _ = arg in do transferImpl this newOwner, DA.Internal.Desugar.Consuming, DA.Internal.Desugar.None) -instance (IsToken t) => HasToAnyChoice t Transfer (ContractId Token) where - _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" -instance (IsToken t) => HasFromAnyChoice t Transfer (ContractId Token) where - _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" -instance (IsToken t) => HasExercise t Transfer (ContractId Token) where - exercise cid = GHC.Types.primitive @"UExerciseInterface" (toTokenContractId cid) -data Split = Split { splitAmount : Int } _choice_TokenSplit : - ( Token -> Split -> [DA.Internal.Desugar.Party] - , DA.Internal.Desugar.ContractId Token -> Token -> Split -> DA.Internal.Desugar.Update ((ContractId Token, ContractId Token)) - , DA.Internal.Desugar.Consuming Token - , DA.Internal.Desugar.Optional (Token -> Split -> [DA.Internal.Desugar.Party]) - ) + (Token -> Split -> [DA.Internal.Desugar.Party], + DA.Internal.Desugar.ContractId Token + -> Token + -> Split + -> DA.Internal.Desugar.Update ((ContractId Token, + ContractId Token)), + DA.Internal.Desugar.Consuming Token, + DA.Internal.Desugar.Optional (Token + -> Split -> [DA.Internal.Desugar.Party])) _choice_TokenSplit = (\ this arg@Split {..} -> let _ = this in @@ -141,115 +236,161 @@ _choice_TokenSplit -> let _ = self in let _ = this in let _ = arg in do splitImpl this splitAmount, DA.Internal.Desugar.Consuming, DA.Internal.Desugar.None) -instance (IsToken t) => HasToAnyChoice t Split ((ContractId Token, - ContractId Token)) where - _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" -instance (IsToken t) => HasFromAnyChoice t Split ((ContractId Token, - ContractId Token)) where - _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" -instance (IsToken t) => HasExercise t Split ((ContractId Token, - ContractId Token)) where - exercise cid = GHC.Types.primitive @"UExerciseInterface" (toTokenContractId cid) -data GHC.Types.DamlTemplate => Asset = Asset { amount : Int, issuer : Party, owner : Party } +data GHC.Types.DamlTemplate => Asset + = Asset {issuer : Party, owner : Party, amount : Int} deriving (Eq, Show) - -instance IsToken Asset where - toToken = GHC.Types.primitive @"EToInterface" - fromToken = GHC.Types.primitive @"EFromInterface" - toTokenContractId = GHC.Types.primitive @"EToInterfaceContractId" - fromTokenContractId = GHC.Types.primitive @"UFromInterfaceContractId" - tokenTypeRep = GHC.Types.primitive @"$TO_TYPE_REP" - getOwner Asset{..} = owner - getAmount Asset{..} = amount - setAmount this x = toToken (this with amount = x) - splitImpl this@Asset {..} - = \ splitAmount - -> do assert (splitAmount < amount) - cid1 <- create this {amount = splitAmount} - cid2 <- create this {amount = amount - splitAmount} - pure (toTokenContractId cid1, toTokenContractId cid2) +instance DA.Internal.Desugar.HasSignatory Asset where + signatory this@Asset {..} + = DA.Internal.Desugar.concat + [DA.Internal.Desugar.toParties (owner), + DA.Internal.Desugar.toParties (issuer)] where _ = this - transferImpl this - = \ newOwner - -> do cid <- create this {owner = newOwner} - pure (toTokenContractId cid) +instance DA.Internal.Desugar.HasObserver Asset where + observer this@Asset {..} + = [] where _ = this - noopImpl this - = \ nothing -> do pure () - -_implements_AssetToken : DA.Internal.Desugar.Implements Asset Token -_implements_AssetToken = DA.Internal.Desugar.Implements - -instance HasCreate Asset where +instance DA.Internal.Desugar.HasEnsure Asset where + ensure this@Asset {..} + = DA.Internal.Desugar.True + where + _ = this +instance DA.Internal.Desugar.HasAgreement Asset where + agreement this@Asset {..} + = "" + where + _ = this +instance DA.Internal.Desugar.HasArchive Asset where + archive cid + = DA.Internal.Desugar.exercise cid DA.Internal.Desugar.Archive + where + _ = cid +instance DA.Internal.Desugar.HasCreate Asset where create = GHC.Types.primitive @"UCreate" - -instance HasSignatory Asset where - signatory Asset{..} = [issuer, owner] - -instance HasEnsure Asset where - ensure this = getAmount this >= 0 - -instance HasAgreement Asset where - agreement _ = "" - -instance HasObserver Asset where - observer _ = [] - -instance HasFetch Asset where +instance DA.Internal.Desugar.HasFetch Asset where fetch = GHC.Types.primitive @"UFetch" - -instance HasExercise Asset Archive () where +instance DA.Internal.Desugar.HasToAnyTemplate Asset where + _toAnyTemplate = GHC.Types.primitive @"EToAnyTemplate" +instance DA.Internal.Desugar.HasFromAnyTemplate Asset where + _fromAnyTemplate = GHC.Types.primitive @"EFromAnyTemplate" +instance DA.Internal.Desugar.HasTemplateTypeRep Asset where + _templateTypeRep = GHC.Types.primitive @"ETemplateTypeRep" +instance DA.Internal.Desugar.HasExercise Asset DA.Internal.Desugar.Archive (()) where exercise = GHC.Types.primitive @"UExercise" - -instance HasArchive Asset where - archive cid = exercise cid Archive +instance DA.Internal.Desugar.HasToAnyChoice Asset DA.Internal.Desugar.Archive (()) where + _toAnyChoice = GHC.Types.primitive @"EToAnyChoice" +instance DA.Internal.Desugar.HasFromAnyChoice Asset DA.Internal.Desugar.Archive (()) where + _fromAnyChoice = GHC.Types.primitive @"EFromAnyChoice" _choice_AssetArchive : - ( Asset -> Archive -> [DA.Internal.Desugar.Party] - , DA.Internal.Desugar.ContractId Asset -> Asset -> Archive -> DA.Internal.Desugar.Update () - , DA.Internal.Desugar.Consuming Asset - , DA.Internal.Desugar.Optional (Asset -> Archive -> [DA.Internal.Desugar.Party]) - ) -_choice_AssetArchive = - ( \a _ -> signatory a - , \_ _ _ -> pure () - , DA.Internal.Desugar.Consuming - , DA.Internal.Desugar.None - ) + (Asset + -> DA.Internal.Desugar.Archive -> [DA.Internal.Desugar.Party], + DA.Internal.Desugar.ContractId Asset + -> Asset + -> DA.Internal.Desugar.Archive -> DA.Internal.Desugar.Update (()), + DA.Internal.Desugar.Consuming Asset, + DA.Internal.Desugar.Optional (Asset + -> DA.Internal.Desugar.Archive -> [DA.Internal.Desugar.Party])) +_choice_AssetArchive + = (\ this@Asset {..} _ + -> let _ = this in DA.Internal.Desugar.signatory this, + \ self this@Asset {..} arg@DA.Internal.Desugar.Archive + -> let _ = self in let _ = this in let _ = arg in pure (), + DA.Internal.Desugar.Consuming, DA.Internal.Desugar.None) -main = scenario do - p <- getParty "Alice" - p `submit` do - cidAsset1 <- create Asset with - issuer = p - owner = p - amount = 15 - let cidToken1 = toTokenContractId cidAsset1 - _ <- exercise cidToken1 (Noop ()) - (cidToken2, cidToken3) <- exercise cidToken1 (Split 10) - token2 <- fetch cidToken2 - getAmount token2 === 10 - case fromToken token2 of - None -> abort "expected Asset" - Some Asset {amount} -> - amount === 10 - token3 <- fetch cidToken3 - getAmount token3 === 5 - case fromToken token3 of - None -> abort "expected Asset" - Some Asset {amount} -> - amount === 5 +instance DA.Internal.Desugar.Implements Asset Token where + toInterface = GHC.Types.primitive @"EToInterface" + fromInterface = GHC.Types.primitive @"EFromInterface" + toInterfaceContractId + = GHC.Types.primitive @"EToInterfaceContractId" + fromInterfaceContractId + = GHC.Types.primitive @"UFromInterfaceContractId" + interfaceTypeRep = GHC.Types.primitive @"$TO_TYPE_REP" - cidToken4 <- exercise cidToken3 (GetRich 20) - token4 <- fetch cidToken4 - getAmount token4 === 25 - case fromToken token4 of - None -> abort "expected Asset" - Some Asset {amount} -> - amount === 25 - unless (tokenTypeRep token3 == tokenTypeRep token4) $ error "Type representations are different." +_method_Asset_Token_getOwner + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"getOwner" + (\ this@Asset {..} -> let _ = this in owner) - pure () +_method_Asset_Token_getAmount + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"getAmount" + (\ this@Asset {..} -> let _ = this in amount) + +_method_Asset_Token_setAmount + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"setAmount" + (\ this@Asset {..} + -> let _ = this + in \ x -> toInterface @_ @Token (this {amount = x})) + +_method_Asset_Token_splitImpl + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"splitImpl" + (\ this@Asset {..} + -> let _ = this + in + \ splitAmount + -> do assert (splitAmount < amount) + cid1 <- create this {amount = splitAmount} + cid2 <- create this {amount = amount - splitAmount} + pure + (toInterfaceContractId @_ @Token cid1, + toInterfaceContractId @_ @Token cid2)) + +_method_Asset_Token_transferImpl + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"transferImpl" + (\ this@Asset {..} + -> let _ = this + in + \ newOwner + -> do cid <- create this {owner = newOwner} + pure (toInterfaceContractId @_ @Token cid)) + +_method_Asset_Token_noopImpl + = DA.Internal.Desugar.mkMethod + @Asset + @Token + @"noopImpl" + (\ this@Asset {..} -> let _ = this in \ nothing -> do pure ()) + +main + = scenario + do p <- getParty "Alice" + p `submitMustFail` + do create Asset {issuer = p, owner = p, amount = - 1} + p `submit` + do cidAsset1 <- create Asset {issuer = p, owner = p, amount = 15} + let cidToken1 = toInterfaceContractId @_ @Token cidAsset1 + _ <- exercise cidToken1 (Noop ()) + (cidToken2, cidToken3) <- exercise cidToken1 (Split 10) + token2 <- fetch cidToken2 + getAmount token2 === 10 + case fromInterface @_ @Token token2 of + None -> abort "expected Asset" + Some Asset {amount} -> amount === 10 + token3 <- fetch cidToken3 + getAmount token3 === 5 + case fromInterface @_ @Token token3 of + None -> abort "expected Asset" + Some Asset {amount} -> amount === 5 + cidToken4 <- exercise cidToken3 (GetRich 20) + token4 <- fetch cidToken4 + getAmount token4 === 25 + case fromInterface @_ @Token token4 of + None -> abort "expected Asset" + Some Asset {amount} -> amount === 25 + pure () diff --git a/compiler/damlc/tests/daml-test-files/InterfaceExperimental.daml b/compiler/damlc/tests/daml-test-files/InterfaceExperimental.daml index 8cc7db855e..859b92f471 100644 --- a/compiler/damlc/tests/daml-test-files/InterfaceExperimental.daml +++ b/compiler/damlc/tests/daml-test-files/InterfaceExperimental.daml @@ -59,11 +59,11 @@ template Asset assert (splitAmount < amount) cid1 <- create this with amount = splitAmount cid2 <- create this with amount = amount - splitAmount - pure (toTokenContractId cid1, toTokenContractId cid2) + pure (toInterfaceContractId @_ @Token cid1, toInterfaceContractId @_ @Token cid2) let transferImpl = \newOwner -> do cid <- create this with owner = newOwner - pure (toTokenContractId cid) + pure (toInterfaceContractId @_ @Token cid) let noopImpl = \nothing -> do pure () @@ -94,11 +94,11 @@ main = scenario do bob <- getParty "Bob" let asset = Asset alice bob 15 let notAsset = NotAsset alice - let token = toToken asset + let token = toInterface @_ @Token asset submit alice do interfaceCreate token interfaceSignatory token === [alice] interfaceObserver token === [bob, alice] - unless (tokenTypeRep token == tokenTypeRep asset) $ abort "TypeReps are not equal" - unless (tokenTypeRep token /= tokenTypeRep notAsset) $ abort "TypeReps are equal" + unless (interfaceTypeRep @_ @Token token == interfaceTypeRep @_ @Token asset) $ abort "TypeReps are not equal" + unless (interfaceTypeRep @_ @Token token /= interfaceTypeRep @_ @Token notAsset) $ abort "TypeReps are equal" pure () diff --git a/compiler/damlc/tests/daml-test-files/InterfacePrecondition.daml b/compiler/damlc/tests/daml-test-files/InterfacePrecondition.daml index 33dfb35ed9..26219d069d 100644 --- a/compiler/damlc/tests/daml-test-files/InterfacePrecondition.daml +++ b/compiler/damlc/tests/daml-test-files/InterfacePrecondition.daml @@ -59,10 +59,10 @@ template Asset assert (splitAmount < amount) cid1 <- create this with amount = splitAmount cid2 <- create this with amount = amount - splitAmount - pure (toToken1ContractId cid1, toToken1ContractId cid2) + pure (toInterfaceContractId @_ @Token1 cid1, toInterfaceContractId @_ @Token1 cid2) let transferImpl = \newOwner -> do cid <- create this with owner = newOwner - pure (toToken1ContractId cid) + pure (toInterfaceContractId @_ @Token1 cid) implements Token2 where diff --git a/daml-script/test/daml/TestInterfaces.daml b/daml-script/test/daml/TestInterfaces.daml index 2e729f4e24..d04991724f 100644 --- a/daml-script/test/daml/TestInterfaces.daml +++ b/daml-script/test/daml/TestInterfaces.daml @@ -50,11 +50,11 @@ template Asset assert (splitAmount < amount) cid1 <- create this with amount = splitAmount cid2 <- create this with amount = amount - splitAmount - pure (toTokenContractId cid1, toTokenContractId cid2) + pure (toInterfaceContractId @_ @Token cid1, toInterfaceContractId @_ @Token cid2) let transferImpl = \newOwner -> do cid <- create this with owner = newOwner - pure (toTokenContractId cid) + pure (toInterfaceContractId @_ @Token cid) let noopImpl = \nothing -> do pure () @@ -66,7 +66,7 @@ test = script do issuer = p owner = p amount = 15 - let cidToken1 = toTokenContractId cidAsset1 + let cidToken1 = toInterfaceContractId @_ @Token cidAsset1 _ <- p `submit` exerciseCmd cidToken1 (Noop ()) diff --git a/language-support/ts/codegen/tests/daml/Main.daml b/language-support/ts/codegen/tests/daml/Main.daml index d5003fb9d6..5569ec7897 100644 --- a/language-support/ts/codegen/tests/daml/Main.daml +++ b/language-support/ts/codegen/tests/daml/Main.daml @@ -199,7 +199,7 @@ template Asset with let getTokenOwner = owner let transferImpl = \newOwner -> do cid <- create Asset with issuer = issuer, owner = newOwner - pure (toTokenContractId cid) + pure (toInterfaceContractId @_ @Token cid) implements Other where let getOtherOwner = owner let somethingImpl = do diff --git a/stack-snapshot.yaml b/stack-snapshot.yaml index 2d3801e69f..b7e695f9d7 100644 --- a/stack-snapshot.yaml +++ b/stack-snapshot.yaml @@ -3,10 +3,10 @@ resolver: lts-18.0 packages: - - archive: https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-42e30fba558f2b7b02d3517092fe5da5.tar.gz - sha256: "a82e889711df26c9fa0d2d4e379dbb9af9974271ebf239b940885c783f68cf5f" - - archive: https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-42e30fba558f2b7b02d3517092fe5da5.tar.gz - sha256: "84979b89ff7dd83dd531edb9b65f16ba5e9fdc71ce90a3d8d276d589546749cb" + - archive: https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-37eea5cf5534b712317d827ad081ca28.tar.gz + sha256: "719ff9dddcf74522a58edfed306f83303947f7bebb6453f55221203ff2692679" + - archive: https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-37eea5cf5534b712317d827ad081ca28.tar.gz + sha256: "6361ac8a39088aa53478d5a6c878801e334e4c55309dc85360bdc6b2e5000335" - github: digital-asset/hlint commit: "c8246c1feb932858ff2b5d7e9e900068a974bf57" sha256: "3da24baf789c5f00211a92e24153e6b88102befaa946ada1f707935554500fe2" diff --git a/stackage_snapshot.json b/stackage_snapshot.json index 57d276bdb1..ecdfc69848 100644 --- a/stackage_snapshot.json +++ b/stackage_snapshot.json @@ -1,6 +1,6 @@ { - "__GENERATED_FILE_DO_NOT_MODIFY_MANUALLY": 952753112, - "all-cabal-hashes": "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/f54ac27a85d067a4f438deb45a321159713452c7", + "__GENERATED_FILE_DO_NOT_MODIFY_MANUALLY": 1382756172, + "all-cabal-hashes": "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/bac27a9f5d1c10d85f9301cdda0a3ba39bd8424d", "resolved": { "Cabal": {"dependencies":[],"location":{"type":"core"},"name":"Cabal","version":"3.2.1.0"}, "Decimal": {"dependencies":["base","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/Decimal-0.5.2/Decimal-0.5.2.tar.gz"},"name":"Decimal","pinned":{"url":["https://hackage.haskell.org/package/Decimal-0.5.2/Decimal-0.5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/Decimal-0.5.2.tar.gz"],"sha256":"a37a0220424e4bcb8cae1d38844c7027ee314449758d0d14ff3e2e0a5c8a87a7","cabal-sha256":"83dd16a1c0737fd35fdb1088af36e1a53034e75090e3f0d4ad32296f1a35a13b"},"version":"0.5.2"}, @@ -11,13 +11,13 @@ "QuickCheck": {"dependencies":["base","containers","deepseq","random","splitmix","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/QuickCheck-2.14.2/QuickCheck-2.14.2.tar.gz"},"name":"QuickCheck","pinned":{"url":["https://hackage.haskell.org/package/QuickCheck-2.14.2/QuickCheck-2.14.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/QuickCheck-2.14.2.tar.gz"],"sha256":"d87b6c85696b601175274361fa62217894401e401e150c3c5d4013ac53cd36f3","cabal-sha256":"4ce29211223d5e6620ebceba34a3ca9ccf1c10c0cf387d48aea45599222ee5aa"},"version":"2.14.2"}, "StateVar": {"dependencies":["base","stm","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/StateVar-1.2.1/StateVar-1.2.1.tar.gz"},"name":"StateVar","pinned":{"url":["https://hackage.haskell.org/package/StateVar-1.2.1/StateVar-1.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/StateVar-1.2.1.tar.gz"],"sha256":"ee261552912b60d8b937f0253615e310e6cc25f9c407001b3bcc2e3d55000f8b","cabal-sha256":"b8bea664120dc78f5c15d9b8c0947d51dbc58a0b63ee49971fa7caac9f3e0845"},"version":"1.2.1"}, "adjunctions": {"dependencies":["array","base","comonad","containers","contravariant","distributive","free","mtl","profunctors","semigroupoids","semigroups","tagged","transformers","transformers-compat","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz"},"name":"adjunctions","pinned":{"url":["https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/adjunctions-4.4.tar.gz"],"sha256":"507c2ef55337ae61c805f8cbc1213dfd7d2b85187342675d662254b8d8a16ae9","cabal-sha256":"2738dd5f5d5e93749adb14a05472e58a96a75d0f299e46371c6f46dc4e97daf9"},"version":"4.4"}, - "aeson": {"dependencies":["attoparsec","base","base-compat-batteries","bytestring","containers","data-fix","deepseq","dlist","ghc-prim","hashable","primitive","scientific","strict","tagged","template-haskell","text","th-abstraction","these","time","time-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz"},"name":"aeson","pinned":{"url":["https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-1.5.6.0.tar.gz"],"sha256":"0361c34be3d2ec945201f02501693436fbda10dcc549469481a084b2de22bfe8","cabal-sha256":"72c170b9fa0a4d1eaf47098902c621d0d95331cda1ebc4d86582bd557756b3ff"},"version":"1.5.6.0"}, + "aeson": {"dependencies":["attoparsec","base","base-compat-batteries","bytestring","containers","data-fix","deepseq","dlist","ghc-prim","hashable","primitive","scientific","strict","tagged","template-haskell","text","th-abstraction","these","time","time-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz"},"name":"aeson","pinned":{"url":["https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-1.5.6.0.tar.gz"],"sha256":"0361c34be3d2ec945201f02501693436fbda10dcc549469481a084b2de22bfe8","cabal-sha256":"45d535d75041eccec635f31fd77d3af8f0682544153a67a569e3e8bad72bb023"},"version":"1.5.6.0"}, "aeson-compat": {"dependencies":["aeson","attoparsec","attoparsec-iso8601","base","base-compat","bytestring","containers","exceptions","hashable","scientific","tagged","text","time","time-locale-compat","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-compat-0.3.9/aeson-compat-0.3.9.tar.gz"},"name":"aeson-compat","pinned":{"url":["https://hackage.haskell.org/package/aeson-compat-0.3.9/aeson-compat-0.3.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-compat-0.3.9.tar.gz"],"sha256":"e043941ba761c13a3854fc087521b864b56b2df874154e42aedb67b2a77f23c8","cabal-sha256":"36cfb542fbcdf51584ec2d681869b3215cdfa1dd5e1040ae781ef8a271a54e95"},"version":"0.3.9"}, "aeson-extra": {"dependencies":["aeson","aeson-compat","attoparsec","attoparsec-iso8601","base","base-compat-batteries","bytestring","containers","deepseq","exceptions","hashable","parsec","recursion-schemes","scientific","semialign","template-haskell","text","these","time","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-extra-0.4.1.3/aeson-extra-0.4.1.3.tar.gz"},"name":"aeson-extra","pinned":{"url":["https://hackage.haskell.org/package/aeson-extra-0.4.1.3/aeson-extra-0.4.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-extra-0.4.1.3.tar.gz"],"sha256":"22e3e2b6d243fb9bc660899dbb677cb6f1f8c348cfc7464082b60ce3fcdc25cc","cabal-sha256":"8ad8e4d28e46280ea98af2e94dcaaf524c396c9d91b1eba867961efc6e7f923f"},"version":"0.4.1.3"}, "aeson-pretty": {"dependencies":["aeson","attoparsec","base","base-compat","bytestring","cmdargs","scientific","text","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz"},"name":"aeson-pretty","pinned":{"url":["https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-pretty-0.8.8.tar.gz"],"sha256":"81cea61cb6dcf32c3f0529ea5cfc98dbea3894152d7f2d9fe1cb051f927ec726","cabal-sha256":"6fcbe24e765457c81d1fc3b89d491bc7e37f7f6e12f0cdd1a3bbb1bacd712877"},"version":"0.8.8"}, "alex": {"dependencies":["array","base","containers","directory"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/alex-3.2.6/alex-3.2.6.tar.gz"},"name":"alex","pinned":{"url":["https://hackage.haskell.org/package/alex-3.2.6/alex-3.2.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/alex-3.2.6.tar.gz"],"sha256":"91aa08c1d3312125fbf4284815189299bbb0be34421ab963b1f2ae06eccc5410","cabal-sha256":"7e15b8ba44f4e858d7e302ae234c05ca10a120c401f0db5ea5bc6135347debca"},"version":"3.2.6"}, "ansi-terminal": {"dependencies":["base","colour"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-terminal-0.11/ansi-terminal-0.11.tar.gz"},"name":"ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/ansi-terminal-0.11/ansi-terminal-0.11.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-terminal-0.11.tar.gz"],"sha256":"c6611b9e51add41db3f79eac30066c06b33a6ca2a09e586b4b361d7f98303793","cabal-sha256":"97470250c92aae14c4c810d7f664c532995ba8910e2ad797b29f22ad0d2d0194"},"version":"0.11"}, - "ansi-wl-pprint": {"dependencies":["ansi-terminal","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz"},"name":"ansi-wl-pprint","pinned":{"url":["https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-wl-pprint-0.6.9.tar.gz"],"sha256":"a7b2e8e7cd3f02f2954e8b17dc60a0ccd889f49e2068ebb15abfa1d42f7a4eac","cabal-sha256":"20d30674f137d43aa0279c2c2cc5e45a5f1c3c57e301852494906158b6313bf7"},"version":"0.6.9"}, + "ansi-wl-pprint": {"dependencies":["ansi-terminal","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz"},"name":"ansi-wl-pprint","pinned":{"url":["https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-wl-pprint-0.6.9.tar.gz"],"sha256":"a7b2e8e7cd3f02f2954e8b17dc60a0ccd889f49e2068ebb15abfa1d42f7a4eac","cabal-sha256":"212144ea0623b1170807a4162db05d87f26cf10b334aeadd0edb377aba06a1ce"},"version":"0.6.9"}, "array": {"dependencies":[],"location":{"type":"core"},"name":"array","version":"0.5.4.0"}, "asn1-encoding": {"dependencies":["asn1-types","base","bytestring","hourglass"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/asn1-encoding-0.9.6/asn1-encoding-0.9.6.tar.gz"},"name":"asn1-encoding","pinned":{"url":["https://hackage.haskell.org/package/asn1-encoding-0.9.6/asn1-encoding-0.9.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/asn1-encoding-0.9.6.tar.gz"],"sha256":"d9f8deabd3b908e5cf83c0d813c08dc0143b3ec1c0d97f660d2cfa02c1c8da0a","cabal-sha256":"27ed8f6043aed79630313bb931f7c8e2b510f0b4586cd55c16ae040c7d1ea098"},"version":"0.9.6"}, "asn1-parse": {"dependencies":["asn1-encoding","asn1-types","base","bytestring"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/asn1-parse-0.9.5/asn1-parse-0.9.5.tar.gz"},"name":"asn1-parse","pinned":{"url":["https://hackage.haskell.org/package/asn1-parse-0.9.5/asn1-parse-0.9.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/asn1-parse-0.9.5.tar.gz"],"sha256":"8f1fe1344d30b39dc594d74df2c55209577722af1497204b4c2b6d6e8747f39e","cabal-sha256":"77c0126d63070df2d82cb4cfa4febb26c4e280f6d854bc778c2fa4d80ce692b8"},"version":"0.9.5"}, @@ -88,7 +88,7 @@ "either": {"dependencies":["base","bifunctors","mtl","profunctors","semigroupoids"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/either-5.0.1.1/either-5.0.1.1.tar.gz"},"name":"either","pinned":{"url":["https://hackage.haskell.org/package/either-5.0.1.1/either-5.0.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/either-5.0.1.1.tar.gz"],"sha256":"0243d51d6a02ecb541e4854a588a9b6219a4690ebcbdb79387dd14ad519cdf27","cabal-sha256":"41167573bf575b7e0e24283a52fba8ce7bed5a7cc2984bba0dce305a0ab66f0d"},"version":"5.0.1.1"}, "entropy": {"dependencies":["Cabal","base","bytestring","directory","filepath","process","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/entropy-0.4.1.6/entropy-0.4.1.6.tar.gz"},"name":"entropy","pinned":{"url":["https://hackage.haskell.org/package/entropy-0.4.1.6/entropy-0.4.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/entropy-0.4.1.6.tar.gz"],"sha256":"adc759ff756a6d71a450422ba511177632f43a33bf673901fd2334f53ef8bf62","cabal-sha256":"49ba23558a717d695724e5f10d9f4040f42db805a9fab774942c44c782f5de4b"},"version":"0.4.1.6"}, "exceptions": {"dependencies":["base","mtl","stm","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz"},"name":"exceptions","pinned":{"url":["https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/exceptions-0.10.4.tar.gz"],"sha256":"4d0bfb4355cffcd67d300811df9d5fe44ea3594ed63750795bfc1f797abd84cf","cabal-sha256":"d2546046d7ba4b460d3bc7fd269cd2c52d0b7fb3cfecc038715dd0881b78a484"},"version":"0.10.4"}, - "extra": {"dependencies":["base","clock","directory","filepath","process","semigroups","time","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz"},"name":"extra","pinned":{"url":["https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/extra-1.7.1.tar.gz"],"sha256":"a47f452a8b012973bff015facefff28d0bbc39910dadcaac9e1b35dbd2ee507f","cabal-sha256":"a9fd1d35a563820f414014f1659769f52726d2031eff6b4628abfcd86729a325"},"version":"1.7.1"}, + "extra": {"dependencies":["base","clock","directory","filepath","process","semigroups","time","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz"},"name":"extra","pinned":{"url":["https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/extra-1.7.1.tar.gz"],"sha256":"a47f452a8b012973bff015facefff28d0bbc39910dadcaac9e1b35dbd2ee507f","cabal-sha256":"f3a0e616bf7fd17f338668080d613a440f946a21d596f651552fcdf1dfc3c27e"},"version":"1.7.1"}, "fast-logger": {"dependencies":["array","auto-update","base","bytestring","directory","easy-file","filepath","text","unix-compat","unix-time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fast-logger-3.0.5/fast-logger-3.0.5.tar.gz"},"name":"fast-logger","pinned":{"url":["https://hackage.haskell.org/package/fast-logger-3.0.5/fast-logger-3.0.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fast-logger-3.0.5.tar.gz"],"sha256":"a693bfda13ea7220dc4d516134880bc0ba5652639f0d5148222f52640d5476d5","cabal-sha256":"fd430f998045aa86226faa29652ee797410a11edd9b77b709be1bedc96f77c4d"},"version":"3.0.5"}, "file-embed": {"dependencies":["base","bytestring","directory","filepath","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/file-embed-0.0.14.0/file-embed-0.0.14.0.tar.gz"},"name":"file-embed","pinned":{"url":["https://hackage.haskell.org/package/file-embed-0.0.14.0/file-embed-0.0.14.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/file-embed-0.0.14.0.tar.gz"],"sha256":"050267dbb2fb9033f16c66659fa739b6972775591fddf747e13f8d71c2f485ac","cabal-sha256":"41df92c8252b33957333fba5b4d3bfae2c6a35fc2582196fdb6a3618b41f5aaf"},"version":"0.0.14.0"}, "filelock": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/filelock-0.1.1.5/filelock-0.1.1.5.tar.gz"},"name":"filelock","pinned":{"url":["https://hackage.haskell.org/package/filelock-0.1.1.5/filelock-0.1.1.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/filelock-0.1.1.5.tar.gz"],"sha256":"50ebea81e8443356af26f32221d4594709d94102445931673fcd94a44e244419","cabal-sha256":"1d394c8ba29e410a57a451fbe6fc650d0392333b6b73ffc33afe1766f81c4486"},"version":"0.1.1.5"}, @@ -100,8 +100,8 @@ "generic-deriving": {"dependencies":["base","containers","ghc-prim","template-haskell","th-abstraction"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generic-deriving-1.14/generic-deriving-1.14.tar.gz"},"name":"generic-deriving","pinned":{"url":["https://hackage.haskell.org/package/generic-deriving-1.14/generic-deriving-1.14.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generic-deriving-1.14.tar.gz"],"sha256":"d0abd5e423960b66867c6149c20b221b1351e3805d1bf787fc4efa3e7bb7cb02","cabal-sha256":"c9c6782a3cdce2f2bcaf891e0ffbf06df871e68498574b73a565771dc084273c"},"version":"1.14"}, "generics-sop": {"dependencies":["base","ghc-prim","sop-core","template-haskell","th-abstraction"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generics-sop-0.5.1.1/generics-sop-0.5.1.1.tar.gz"},"name":"generics-sop","pinned":{"url":["https://hackage.haskell.org/package/generics-sop-0.5.1.1/generics-sop-0.5.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generics-sop-0.5.1.1.tar.gz"],"sha256":"81b7c38b5c2a1ae3c790b1707a0e2a2031430e33b3683f88e2daa5b59ae4c5d8","cabal-sha256":"522a1a1da05d5acc03da448fa603c038cc15b991272846a591e26e7505d2b73a"},"version":"0.5.1.1"}, "ghc-byteorder": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ghc-byteorder-4.11.0.0.10/ghc-byteorder-4.11.0.0.10.tar.gz"},"name":"ghc-byteorder","pinned":{"url":["https://hackage.haskell.org/package/ghc-byteorder-4.11.0.0.10/ghc-byteorder-4.11.0.0.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ghc-byteorder-4.11.0.0.10.tar.gz"],"sha256":"86e50a89798181db4f44ec3848fc52940c73098e88549a351ceb54fefc691fb6","cabal-sha256":"e345720de7b28ba1bf434775d34d3b94da8e8dd5dc24469f008e1f82717c0352"},"version":"4.11.0.0.10"}, - "ghc-lib": {"dependencies":["alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-lib-parser","ghc-prim","happy","hpc","pretty","process","rts","time","transformers","unix"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-f1468b856c4a52a7826bfc0c29dee4f4.tar.gz"},"name":"ghc-lib","pinned":{"sha256":"f939726fdc6dbe67db4aeac86b3f6bcd88997dcb5648dc0d7e7f221760074165","strip-prefix":"ghc-lib-8.8.1.20211108"},"version":"8.8.1.20211108"}, - "ghc-lib-parser": {"dependencies":["alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-prim","happy","hpc","pretty","process","time","transformers","unix"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-f1468b856c4a52a7826bfc0c29dee4f4.tar.gz"},"name":"ghc-lib-parser","pinned":{"sha256":"fbbca516fc2f8fab9d3095cde1edb98d3f05af9ea2dfb927275ed745b394685c","strip-prefix":"ghc-lib-parser-8.8.1.20211108"},"version":"8.8.1.20211108"}, + "ghc-lib": {"dependencies":["alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-lib-parser","ghc-prim","happy","hpc","pretty","process","rts","time","transformers","unix"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-37eea5cf5534b712317d827ad081ca28.tar.gz"},"name":"ghc-lib","pinned":{"sha256":"719ff9dddcf74522a58edfed306f83303947f7bebb6453f55221203ff2692679","strip-prefix":"ghc-lib-8.8.1.20211118"},"version":"8.8.1.20211118"}, + "ghc-lib-parser": {"dependencies":["alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-prim","happy","hpc","pretty","process","time","transformers","unix"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-37eea5cf5534b712317d827ad081ca28.tar.gz"},"name":"ghc-lib-parser","pinned":{"sha256":"6361ac8a39088aa53478d5a6c878801e334e4c55309dc85360bdc6b2e5000335","strip-prefix":"ghc-lib-parser-8.8.1.20211118"},"version":"8.8.1.20211118"}, "ghc-lib-parser-ex": {"dependencies":["base","bytestring","containers","extra","ghc-lib-parser","uniplate"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ghc-lib-parser-ex-8.8.5.8/ghc-lib-parser-ex-8.8.5.8.tar.gz"},"name":"ghc-lib-parser-ex","pinned":{"url":["https://hackage.haskell.org/package/ghc-lib-parser-ex-8.8.5.8/ghc-lib-parser-ex-8.8.5.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ghc-lib-parser-ex-8.8.5.8.tar.gz"],"sha256":"b36ef8b49da4e8c78b00dca9b9546b7d4db0b09b10da5e313d3f0dbb4af581d7","cabal-sha256":"04f164fd6a4a5b0c5627cf7fadd79174c3b1d4c696dc481a9909266bd6a2a6aa"},"version":"8.8.5.8"}, "ghc-prim": {"dependencies":[],"location":{"type":"core"},"name":"ghc-prim","version":"0.6.1"}, "ghcide": {"dependencies":["aeson","async","base","binary","bytestring","containers","data-default","deepseq","dependent-map","dependent-sum","directory","extra","filepath","fuzzy","ghc-lib","ghc-lib-parser","haddock-library","hashable","hslogger","lsp","lsp-types","mtl","network-uri","prettyprinter","prettyprinter-ansi-terminal","regex-tdfa","rope-utf16-splay","safe-exceptions","shake","some","sorted-list","stm","syb","text","time","transformers","unix","unliftio","unordered-containers","utf8-string"],"location":{"type":"vendored"},"name":"ghcide","version":"0.1.0"}, @@ -122,7 +122,7 @@ "hpc": {"dependencies":[],"location":{"type":"core"},"name":"hpc","version":"0.6.1.0"}, "hpp": {"dependencies":["base","bytestring","directory","filepath","ghc-prim","time","transformers","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hpp-0.6.3/hpp-0.6.3.tar.gz"},"name":"hpp","pinned":{"url":["https://hackage.haskell.org/package/hpp-0.6.3/hpp-0.6.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hpp-0.6.3.tar.gz"],"sha256":"7ac736cdc29799d196dbda74f0930cdeb3c526267798bbc261181053019cd53e","cabal-sha256":"d367b4803467c9a7817b4a4640f0d3d4b73269fd6d0dbf5dcda69e5a0938b2e2"},"version":"0.6.3"}, "hscolour": {"dependencies":["base","containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz"},"name":"hscolour","pinned":{"url":["https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hscolour-1.24.4.tar.gz"],"sha256":"243332b082294117f37b2c2c68079fa61af68b36223b3fc07594f245e0e5321d","cabal-sha256":"3a329fa0ea9138f651088f1fa25522aabeab0eb591932d3fd56c66736bbe78be"},"version":"1.24.4"}, - "hslogger": {"dependencies":["base","bytestring","containers","deepseq","network","network-bsd","old-locale","time","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz"},"name":"hslogger","pinned":{"url":["https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hslogger-1.3.1.0.tar.gz"],"sha256":"7f2364f6c0b9c5b85a257267a335816126ef2471c817a42797a5d3c57acaca5b","cabal-sha256":"b3fdd8c49c0c51adc9af8d7456e46ba580ad5ec478e18e92c3bb158d8ac38908"},"version":"1.3.1.0"}, + "hslogger": {"dependencies":["base","bytestring","containers","deepseq","network","network-bsd","old-locale","time","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz"},"name":"hslogger","pinned":{"url":["https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hslogger-1.3.1.0.tar.gz"],"sha256":"7f2364f6c0b9c5b85a257267a335816126ef2471c817a42797a5d3c57acaca5b","cabal-sha256":"e40119589bc3299fe3f1ae84c067b0b056f96338b37daa19e6151d6233f9a2e1"},"version":"1.3.1.0"}, "hspec": {"dependencies":["QuickCheck","base","hspec-core","hspec-discover","hspec-expectations"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-2.7.10/hspec-2.7.10.tar.gz"},"name":"hspec","pinned":{"url":["https://hackage.haskell.org/package/hspec-2.7.10/hspec-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-2.7.10.tar.gz"],"sha256":"3c1bbda1962b2a493ad0bea0039720011948ac194c4c63d1c9f44d9c6be6147c","cabal-sha256":"c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce"},"version":"2.7.10"}, "hspec-core": {"dependencies":["HUnit","QuickCheck","ansi-terminal","array","base","call-stack","clock","deepseq","directory","filepath","hspec-expectations","quickcheck-io","random","setenv","stm","tf-random","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-core-2.7.10/hspec-core-2.7.10.tar.gz"},"name":"hspec-core","pinned":{"url":["https://hackage.haskell.org/package/hspec-core-2.7.10/hspec-core-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-core-2.7.10.tar.gz"],"sha256":"61d34e914b7c6bc01cac654de7bcb587f6b17969c0e49808512ddbffcaf5698a","cabal-sha256":"2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13"},"version":"2.7.10"}, "hspec-discover": {"dependencies":["base","directory","filepath"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-discover-2.7.10/hspec-discover-2.7.10.tar.gz"},"name":"hspec-discover","pinned":{"url":["https://hackage.haskell.org/package/hspec-discover-2.7.10/hspec-discover-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-discover-2.7.10.tar.gz"],"sha256":"0a576d00c67f1b093062130d0dcdaffb13c6812653db18f49e3a1db346dbdf8f","cabal-sha256":"d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f"},"version":"2.7.10"}, @@ -178,7 +178,7 @@ "optics-extra": {"dependencies":["array","base","bytestring","containers","hashable","indexed-profunctors","mtl","optics-core","text","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optics-extra-0.3/optics-extra-0.3.tar.gz"},"name":"optics-extra","pinned":{"url":["https://hackage.haskell.org/package/optics-extra-0.3/optics-extra-0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optics-extra-0.3.tar.gz"],"sha256":"a4d6155814111a5c6ce89640915ba5987296fec3cecc766ece3d4112abfd7697","cabal-sha256":"68c3dd038cb1b9a43107b645e33adfd14f085f5923ad01b42d222ee1b6aaa38f"},"version":"0.3"}, "optics-th": {"dependencies":["base","containers","mtl","optics-core","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optics-th-0.3.0.2/optics-th-0.3.0.2.tar.gz"},"name":"optics-th","pinned":{"url":["https://hackage.haskell.org/package/optics-th-0.3.0.2/optics-th-0.3.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optics-th-0.3.0.2.tar.gz"],"sha256":"80f0cbb1cda044631ef421a0112e2d9a9868c22d95e845d97902d0fbf822b1d7","cabal-sha256":"e786f290c237a3236eda8814957da882227c05ed063d865d4ab1af08d638244f"},"version":"0.3.0.2"}, "optional-args": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optional-args-1.0.2/optional-args-1.0.2.tar.gz"},"name":"optional-args","pinned":{"url":["https://hackage.haskell.org/package/optional-args-1.0.2/optional-args-1.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optional-args-1.0.2.tar.gz"],"sha256":"2e3454ad77cba80b15c02dbe1915889fafa81a22deb7fe5e7e01b0dd8d85b0e4","cabal-sha256":"83f6a4c838bf011e85ea5573bfd4d7f8a8516d97c64d07135b1713526135aa39"},"version":"1.0.2"}, - "optparse-applicative": {"dependencies":["ansi-wl-pprint","base","process","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz"},"name":"optparse-applicative","pinned":{"url":["https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-applicative-0.16.1.0.tar.gz"],"sha256":"6205278362f333c52256b9dd3edf5f8fe0f84f00cb9ee000291089f6eaccd69a","cabal-sha256":"16ebd7054b2265c1aad16c1d19dc503695fbfc67b35203d9952fd577d08c0110"},"version":"0.16.1.0"}, + "optparse-applicative": {"dependencies":["ansi-wl-pprint","base","process","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz"},"name":"optparse-applicative","pinned":{"url":["https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-applicative-0.16.1.0.tar.gz"],"sha256":"6205278362f333c52256b9dd3edf5f8fe0f84f00cb9ee000291089f6eaccd69a","cabal-sha256":"418c22ed6a19124d457d96bc66bd22c93ac22fad0c7100fe4972bbb4ac989731"},"version":"0.16.1.0"}, "optparse-generic": {"dependencies":["Only","base","bytestring","optparse-applicative","system-filepath","text","time","transformers","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-generic-1.4.4/optparse-generic-1.4.4.tar.gz"},"name":"optparse-generic","pinned":{"url":["https://hackage.haskell.org/package/optparse-generic-1.4.4/optparse-generic-1.4.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-generic-1.4.4.tar.gz"],"sha256":"e44853c0a3def2556cec31337db411d6404d7f81d505662f8ebac68e119bc077","cabal-sha256":"3ad4624ae34193df88bee3d9af1f24e039482424d853fbbf854e7c711a41b5f8"},"version":"1.4.4"}, "parallel": {"dependencies":["array","base","containers","deepseq","ghc-prim"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz"},"name":"parallel","pinned":{"url":["https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parallel-3.2.2.0.tar.gz"],"sha256":"170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6","cabal-sha256":"19ff631f3a26ee7cf0603e2b80fc375d77d3f350ae460ae72fe4cf5da665c90b"},"version":"3.2.2.0"}, "parameterized": {"dependencies":["base","data-diverse","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parameterized-0.5.0.0/parameterized-0.5.0.0.tar.gz"},"name":"parameterized","pinned":{"url":["https://hackage.haskell.org/package/parameterized-0.5.0.0/parameterized-0.5.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parameterized-0.5.0.0.tar.gz"],"sha256":"d76bc473c671f3c448cc0683ec44f4495cb21938ab27a8e2c35a94683a373346","cabal-sha256":"880717fbb958de1bac015f0a375ab6636f162a72483d987a11e305da6fac6c97"},"version":"0.5.0.0"}, @@ -194,9 +194,9 @@ "prettyprinter": {"dependencies":["base","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-1.7.0/prettyprinter-1.7.0.tar.gz"},"name":"prettyprinter","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-1.7.0/prettyprinter-1.7.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-1.7.0.tar.gz"],"sha256":"591b87ce8a5cff39d66cb1c156c7d27d04de57952f16eb3ce3afe309ac26e0a7","cabal-sha256":"6a9569e21fa61163a7f066d23d701e23e917893e8f39733d6e617ec72787ae5f"},"version":"1.7.0"}, "prettyprinter-ansi-terminal": {"dependencies":["ansi-terminal","base","prettyprinter","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz"},"name":"prettyprinter-ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-ansi-terminal-1.1.2.tar.gz"],"sha256":"e26b7338b90830a126e210ec164426bd3da7d099a319d1287a40e3efce2a1799","cabal-sha256":"90b3b7650bc5b9f0e58da43621d23c817acfc0cf5ce71244b9bd11b8c9f95e3a"},"version":"1.1.2"}, "primes": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primes-0.2.1.0/primes-0.2.1.0.tar.gz"},"name":"primes","pinned":{"url":["https://hackage.haskell.org/package/primes-0.2.1.0/primes-0.2.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primes-0.2.1.0.tar.gz"],"sha256":"74d66558fb638ea4d31eae2fe1a294cb5a9d64491314305d74a11d93f277c65b","cabal-sha256":"94885df2e13153e439ca9c6eb1893726776ca7022128fe860278294bad49d6a9"},"version":"0.2.1.0"}, - "primitive": {"dependencies":["base","deepseq","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz"},"name":"primitive","pinned":{"url":["https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primitive-0.7.1.0.tar.gz"],"sha256":"6bebecfdf2a57787d9fd5231bfd612b65a92edd7b33a973b2a0f11312b89a3f0","cabal-sha256":"29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f"},"version":"0.7.1.0"}, + "primitive": {"dependencies":["base","deepseq","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz"},"name":"primitive","pinned":{"url":["https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primitive-0.7.1.0.tar.gz"],"sha256":"6bebecfdf2a57787d9fd5231bfd612b65a92edd7b33a973b2a0f11312b89a3f0","cabal-sha256":"cef1cfd0eade2be8e276520c897e20ebe3d4a7371d5a06c82648af4181cab326"},"version":"0.7.1.0"}, "process": {"dependencies":[],"location":{"type":"core"},"name":"process","version":"1.6.9.0"}, - "profunctors": {"dependencies":["base","base-orphans","bifunctors","comonad","contravariant","distributive","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz"},"name":"profunctors","pinned":{"url":["https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/profunctors-5.6.2.tar.gz"],"sha256":"65955d7b50525a4a3bccdab1d982d2ae342897fd38140d5a94b5ef3800d8c92a","cabal-sha256":"d91e81cf7fc186d616543d5ca7aad78b1c45c692486ca75a3f022466ff8e4bad"},"version":"5.6.2"}, + "profunctors": {"dependencies":["base","base-orphans","bifunctors","comonad","contravariant","distributive","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz"},"name":"profunctors","pinned":{"url":["https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/profunctors-5.6.2.tar.gz"],"sha256":"65955d7b50525a4a3bccdab1d982d2ae342897fd38140d5a94b5ef3800d8c92a","cabal-sha256":"3d3685119243a7ebf984fa6af03299d156ab7674a432e2e15ecee2a4fd420fb6"},"version":"5.6.2"}, "proto3-suite": {"dependencies":["QuickCheck","aeson","aeson-pretty","attoparsec","base","base64-bytestring","binary","bytestring","cereal","containers","contravariant","deepseq","filepath","foldl","hashable","haskell-src","insert-ordered-containers","lens","mtl","neat-interpolation","optparse-applicative","optparse-generic","parsec","parsers","pretty","pretty-show","proto3-wire","quickcheck-instances","range-set-list","safe","swagger2","system-filepath","text","transformers","turtle","vector"],"location":{"type":"vendored"},"name":"proto3-suite","version":"0.4.2.0"}, "proto3-wire": {"dependencies":["QuickCheck","base","bytestring","cereal","containers","deepseq","ghc-prim","hashable","parameterized","primitive","safe","text","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/proto3-wire-1.2.0/proto3-wire-1.2.0.tar.gz"},"name":"proto3-wire","pinned":{"url":["https://hackage.haskell.org/package/proto3-wire-1.2.0/proto3-wire-1.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/proto3-wire-1.2.0.tar.gz"],"sha256":"625a7165ede6e348ac4a9474498879e0319d3b833dbdde9153865b6909cc36f7","cabal-sha256":"898c88614ef328fe74d6abc153387a30855af7ccfcebf3b419681133e0fb9291"},"version":"1.2.0"}, "quickcheck-instances": {"dependencies":["QuickCheck","array","base","bytestring","case-insensitive","containers","data-fix","hashable","integer-logarithms","old-time","scientific","splitmix","strict","tagged","text","these","time","time-compat","transformers","transformers-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/quickcheck-instances-0.3.25.2/quickcheck-instances-0.3.25.2.tar.gz"},"name":"quickcheck-instances","pinned":{"url":["https://hackage.haskell.org/package/quickcheck-instances-0.3.25.2/quickcheck-instances-0.3.25.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/quickcheck-instances-0.3.25.2.tar.gz"],"sha256":"70ccf54c6553d6a23b4ee48dc02f1e4120cbb9a609e03af073b93541b35a1846","cabal-sha256":"083b84b91fccb3bbf22cd906f5bc731c8e6ee96c7554e892985452f2d61d4ad3"},"version":"0.3.25.2"}, @@ -205,7 +205,7 @@ "range-set-list": {"dependencies":["base","containers","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/range-set-list-0.1.3.1/range-set-list-0.1.3.1.tar.gz"},"name":"range-set-list","pinned":{"url":["https://hackage.haskell.org/package/range-set-list-0.1.3.1/range-set-list-0.1.3.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/range-set-list-0.1.3.1.tar.gz"],"sha256":"12e8d9cb99a2847da32934ed7f44a5acedaa59d8fa19eff0f46aa77921460c55","cabal-sha256":"1bd9640aa97d8e1599a27a0f2e620040b4fdbc5cf2c5ff65efde0e2c18fd6521"},"version":"0.1.3.1"}, "recursion-schemes": {"dependencies":["base","base-orphans","comonad","containers","data-fix","free","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/recursion-schemes-5.2.2.1/recursion-schemes-5.2.2.1.tar.gz"},"name":"recursion-schemes","pinned":{"url":["https://hackage.haskell.org/package/recursion-schemes-5.2.2.1/recursion-schemes-5.2.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/recursion-schemes-5.2.2.1.tar.gz"],"sha256":"bee32985de5560ba69ef1503eff041091ddaffd68ba8ad736a8fcd95971f02db","cabal-sha256":"fed7167e83698147d7c078bbb1fe74451f96c7c55ed9986c734d268070d85864"},"version":"5.2.2.1"}, "refact": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/refact-0.3.0.2/refact-0.3.0.2.tar.gz"},"name":"refact","pinned":{"url":["https://hackage.haskell.org/package/refact-0.3.0.2/refact-0.3.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/refact-0.3.0.2.tar.gz"],"sha256":"0ad029727797c8ca5d179c7abf1bfc135d86a7d72cf93785ee12ad243aeb1f6c","cabal-sha256":"4ea82b93debdc0711e1bc4b5d8989b9e19613f369ff2049da33c5250b8d33bcd"},"version":"0.3.0.2"}, - "reflection": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz"},"name":"reflection","pinned":{"url":["https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reflection-2.1.6.tar.gz"],"sha256":"bf3e14917ebb329a53701a3cce0afe670f20037a0148dbfa5cbfa574ed6ba6cd","cabal-sha256":"044acb7caf41a9d8246878f849baed2dffbc4582d0a1e5c7c079d4287239e970"},"version":"2.1.6"}, + "reflection": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz"},"name":"reflection","pinned":{"url":["https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reflection-2.1.6.tar.gz"],"sha256":"bf3e14917ebb329a53701a3cce0afe670f20037a0148dbfa5cbfa574ed6ba6cd","cabal-sha256":"f41afef54a696377bb7591e12969a56e7a4a1cf1d2a32210ab24c6a7aa9bd7ae"},"version":"2.1.6"}, "regex-base": {"dependencies":["array","base","bytestring","containers","mtl","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/regex-base-0.94.0.0/regex-base-0.94.0.0.tar.gz"},"name":"regex-base","pinned":{"url":["https://hackage.haskell.org/package/regex-base-0.94.0.0/regex-base-0.94.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/regex-base-0.94.0.0.tar.gz"],"sha256":"c41f82f5fc1157c961a4cbdc0cd5561e5aa44f339ce6e706d978d97e0ca6b914","cabal-sha256":"44aa95ca762294ffbb28cf0af9c567d93b5d2c56e4f38ce5385a257d899f968e"},"version":"0.94.0.0"}, "regex-tdfa": {"dependencies":["array","base","bytestring","containers","mtl","parsec","regex-base","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/regex-tdfa-1.3.1.0/regex-tdfa-1.3.1.0.tar.gz"},"name":"regex-tdfa","pinned":{"url":["https://hackage.haskell.org/package/regex-tdfa-1.3.1.0/regex-tdfa-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/regex-tdfa-1.3.1.0.tar.gz"],"sha256":"15c376783d397b3b9933cf35980808feddde273bd6f2445babbccb2f76a42ec0","cabal-sha256":"eb8d0f007cf45faca8574f56f0d19c9b02bc529ef1688d8f8a9751ce7dc36cc3"},"version":"1.3.1.0"}, "repline": {"dependencies":["base","containers","exceptions","haskeline","mtl","process"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/repline-0.4.0.0/repline-0.4.0.0.tar.gz"},"name":"repline","pinned":{"url":["https://hackage.haskell.org/package/repline-0.4.0.0/repline-0.4.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/repline-0.4.0.0.tar.gz"],"sha256":"43c28c49c8e16276d32d0889f37f750d7c7a8d2758f1d35a9f36e68944e457b7","cabal-sha256":"3324479e497d27c40c3d4762bffc52058f9921621d20d2947dcf9a554b94cd0d"},"version":"0.4.0.0"}, @@ -217,7 +217,7 @@ "safe-exceptions": {"dependencies":["base","deepseq","exceptions","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/safe-exceptions-0.1.7.1/safe-exceptions-0.1.7.1.tar.gz"},"name":"safe-exceptions","pinned":{"url":["https://hackage.haskell.org/package/safe-exceptions-0.1.7.1/safe-exceptions-0.1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/safe-exceptions-0.1.7.1.tar.gz"],"sha256":"4bf6dd0a2b18279be843ece044a89248553c092bb1fc5bd7efa55c1c1d537d3e","cabal-sha256":"ccf8dacc48a8fbc8450de9d3ae6f949067bb0c96d52bb66e3044b5cd046382d5"},"version":"0.1.7.1"}, "scientific": {"dependencies":["base","binary","bytestring","containers","deepseq","hashable","integer-logarithms","integer-simple","primitive","template-haskell","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/scientific-0.3.7.0/scientific-0.3.7.0.tar.gz"},"name":"scientific","pinned":{"url":["https://hackage.haskell.org/package/scientific-0.3.7.0/scientific-0.3.7.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/scientific-0.3.7.0.tar.gz"],"sha256":"a3a121c4b3d68fb8b9f8c709ab012e48f090ed553609247a805ad070d6b343a9","cabal-sha256":"d7edb4dfb320e7b9cc9d503ca435d22983a236db06c7b4f3e81c099a9fd4cd73"},"version":"0.3.7.0"}, "semialign": {"dependencies":["base","containers","hashable","semigroupoids","tagged","these","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semialign-1.1.0.1/semialign-1.1.0.1.tar.gz"},"name":"semialign","pinned":{"url":["https://hackage.haskell.org/package/semialign-1.1.0.1/semialign-1.1.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semialign-1.1.0.1.tar.gz"],"sha256":"9810bddff641bf7446a1939e5f337e368f894d06e3995a536704b3e16b241a87","cabal-sha256":"44fa0af083af848efef9ac5c6cfa0d3a26fcb58d209942fae2ff941bf0f8cbe7"},"version":"1.1.0.1"}, - "semigroupoids": {"dependencies":["base","base-orphans","bifunctors","comonad","containers","contravariant","distributive","hashable","tagged","template-haskell","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz"},"name":"semigroupoids","pinned":{"url":["https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroupoids-5.3.5.tar.gz"],"sha256":"552f18e13ef347118911c950957e4adcda0a1f948e274f29ec449cc413d3c6b0","cabal-sha256":"e9ad7265a3baca520054fd2f9d6b1ebe6779502dc377550c99dee43e88555a8f"},"version":"5.3.5"}, + "semigroupoids": {"dependencies":["base","base-orphans","bifunctors","comonad","containers","contravariant","distributive","hashable","tagged","template-haskell","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz"},"name":"semigroupoids","pinned":{"url":["https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroupoids-5.3.5.tar.gz"],"sha256":"552f18e13ef347118911c950957e4adcda0a1f948e274f29ec449cc413d3c6b0","cabal-sha256":"de84e651b967263a8348e18533bf02c9fd21fab83d8c041371dfcf61002bd436"},"version":"5.3.5"}, "semigroups": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz"},"name":"semigroups","pinned":{"url":["https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroups-0.19.1.tar.gz"],"sha256":"79e761e64b862564a3470d5d356cb6b060b14452d675859aed3b2d1e14646648","cabal-sha256":"aa5f4b64b0a440b6c7eb1a783a49484c0f169ae8bb08feeadbfe0e84556ca376"},"version":"0.19.1"}, "semver": {"dependencies":["attoparsec","base","deepseq","hashable","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semver-0.4.0.1/semver-0.4.0.1.tar.gz"},"name":"semver","pinned":{"url":["https://hackage.haskell.org/package/semver-0.4.0.1/semver-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semver-0.4.0.1.tar.gz"],"sha256":"7c47e326684efe407b2dc77924aa71c57c712465a9ed39c4097e6c1e1a1ff641","cabal-sha256":"a4f77491e1e7c8101e203748f6122918224590a44f81c39fefc62e27b448868d"},"version":"0.4.0.1"}, "setenv": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz"},"name":"setenv","pinned":{"url":["https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/setenv-0.1.1.3.tar.gz"],"sha256":"e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32","cabal-sha256":"c5916ac0d2a828473cd171261328a290afe0abd799db1ac8c310682fe778c45b"},"version":"0.1.1.3"}, @@ -235,7 +235,7 @@ "stm-chans": {"dependencies":["Cabal","base","stm"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz"},"name":"stm-chans","pinned":{"url":["https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/stm-chans-3.0.0.4.tar.gz"],"sha256":"2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738","cabal-sha256":"e2eef3cea5251628f7b2ad22c24a1e5d08b83c19be4bd886ab0d7fed58ef2a6d"},"version":"3.0.0.4"}, "stm-conduit": {"dependencies":["async","base","cereal","cereal-conduit","conduit","conduit-extra","directory","exceptions","monad-loops","resourcet","stm","stm-chans","transformers","unliftio"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/stm-conduit-4.0.1/stm-conduit-4.0.1.tar.gz"},"name":"stm-conduit","pinned":{"url":["https://hackage.haskell.org/package/stm-conduit-4.0.1/stm-conduit-4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/stm-conduit-4.0.1.tar.gz"],"sha256":"e80e5be72a4564fa45e1e27f91c0984e12d2a736d0ceb9594350d573efee1442","cabal-sha256":"71f477c617400fb5bee74557416d7dac17dccea0663ec29bf9ca67b52703637d"},"version":"4.0.1"}, "streaming-commons": {"dependencies":["array","async","base","bytestring","directory","network","process","random","stm","text","transformers","unix","zlib"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/streaming-commons-0.2.2.1/streaming-commons-0.2.2.1.tar.gz"},"name":"streaming-commons","pinned":{"url":["https://hackage.haskell.org/package/streaming-commons-0.2.2.1/streaming-commons-0.2.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/streaming-commons-0.2.2.1.tar.gz"],"sha256":"306940bf4878a0b714e6746a7f934d018100efc86332c176a648014bfe1e81dd","cabal-sha256":"28abce35b48dcfb871926dad4cb37bdf737372892b4e5222abc97ca31f2ac738"},"version":"0.2.2.1"}, - "strict": {"dependencies":["assoc","base","binary","bytestring","deepseq","ghc-prim","hashable","text","these","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz"},"name":"strict","pinned":{"url":["https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/strict-0.4.0.1.tar.gz"],"sha256":"dff6abc08ad637e51891bb8b475778c40926c51219eda60fd64f0d9680226241","cabal-sha256":"ab041906af66c97de0ded33846865c9794c1a2cfce13d7e68e9b46922faf31ff"},"version":"0.4.0.1"}, + "strict": {"dependencies":["assoc","base","binary","bytestring","deepseq","ghc-prim","hashable","text","these","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz"},"name":"strict","pinned":{"url":["https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/strict-0.4.0.1.tar.gz"],"sha256":"dff6abc08ad637e51891bb8b475778c40926c51219eda60fd64f0d9680226241","cabal-sha256":"ca6fba3bd2ddc0b70f31286192aa36359a99f1c0cd50e821ffc37bee772fd68f"},"version":"0.4.0.1"}, "swagger2": {"dependencies":["Cabal","QuickCheck","aeson","aeson-pretty","base","base-compat-batteries","bytestring","cabal-doctest","containers","cookie","generics-sop","hashable","http-media","insert-ordered-containers","lens","mtl","network","optics-core","optics-th","scientific","template-haskell","text","time","transformers","transformers-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/swagger2-2.6/swagger2-2.6.tar.gz"},"name":"swagger2","pinned":{"url":["https://hackage.haskell.org/package/swagger2-2.6/swagger2-2.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/swagger2-2.6.tar.gz"],"sha256":"682afe3b43d6b7c394cab330bb48692b8045dff8db3e8913bbfabee0fa8c706e","cabal-sha256":"12c0752b397da71e286a2f8998dfd842376df56f624deb0ad8d858c6e20cb8bd"},"version":"2.6"}, "syb": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/syb-0.7.2.1/syb-0.7.2.1.tar.gz"},"name":"syb","pinned":{"url":["https://hackage.haskell.org/package/syb-0.7.2.1/syb-0.7.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/syb-0.7.2.1.tar.gz"],"sha256":"1807c66f77e66786739387f0ae9f16d150d1cfa9d626afcb729f0e9b442a8d96","cabal-sha256":"bf42655a213402215299e435c52f799e76cbec0b984cd7153d6b9af8a1c0803f"},"version":"0.7.2.1"}, "system-fileio": {"dependencies":["base","bytestring","system-filepath","text","time","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/system-fileio-0.3.16.4/system-fileio-0.3.16.4.tar.gz"},"name":"system-fileio","pinned":{"url":["https://hackage.haskell.org/package/system-fileio-0.3.16.4/system-fileio-0.3.16.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/system-fileio-0.3.16.4.tar.gz"],"sha256":"34e58b88a19a69ff1a559e211af6edb596e33ee1b1d5f44490febf325c78c6c7","cabal-sha256":"ca3a89469943828bcd526bed2d6943541e3e672464fd58abab3443b63f59c5ba"},"version":"0.3.16.4"}, @@ -260,7 +260,7 @@ "th-abstraction": {"dependencies":["base","containers","ghc-prim","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-abstraction-0.4.2.0/th-abstraction-0.4.2.0.tar.gz"},"name":"th-abstraction","pinned":{"url":["https://hackage.haskell.org/package/th-abstraction-0.4.2.0/th-abstraction-0.4.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-abstraction-0.4.2.0.tar.gz"],"sha256":"ea06b2cda25fc4b52dac48cc23e5a756f997df8985ecaee5a554202508a11c40","cabal-sha256":"6ba7b201931f614173755f060fdf98f02095df68c1f7bc3e2691cf9d443e81f9"},"version":"0.4.2.0"}, "th-compat": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-compat-0.1.2/th-compat-0.1.2.tar.gz"},"name":"th-compat","pinned":{"url":["https://hackage.haskell.org/package/th-compat-0.1.2/th-compat-0.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-compat-0.1.2.tar.gz"],"sha256":"2bc45d0199de3dc65ebc9b71251799f5238869dbc6a66bdf0c06c7e23d603801","cabal-sha256":"3d55de1adc542c1a870c9ada90da2fbbe5f4e8bcd3eed545a55c3df9311b32a8"},"version":"0.1.2"}, "th-extras": {"dependencies":["base","syb","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-extras-0.0.0.4/th-extras-0.0.0.4.tar.gz"},"name":"th-extras","pinned":{"url":["https://hackage.haskell.org/package/th-extras-0.0.0.4/th-extras-0.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-extras-0.0.0.4.tar.gz"],"sha256":"8feff450aaf28ec4f08c45a5656c62879861a8e7f45591cb367d5351ddc3fbed","cabal-sha256":"2f408c0f427530f36beb19c733a7a57f67b727713f9bb942b64f3b2e0e2932bf"},"version":"0.0.0.4"}, - "these": {"dependencies":["assoc","base","binary","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz"},"name":"these","pinned":{"url":["https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/these-1.1.1.1.tar.gz"],"sha256":"d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508","cabal-sha256":"2deb8cb10e5ad68b073509c29b2aebd25bf59149b5bb8b3b38b2c6109802725d"},"version":"1.1.1.1"}, + "these": {"dependencies":["assoc","base","binary","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz"},"name":"these","pinned":{"url":["https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/these-1.1.1.1.tar.gz"],"sha256":"d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508","cabal-sha256":"f069e766b8fed73d457fca20cc197f5c539bcdd03d7636e478ddf14dbb67684a"},"version":"1.1.1.1"}, "time": {"dependencies":[],"location":{"type":"core"},"name":"time","version":"1.9.3"}, "time-compat": {"dependencies":["base","base-orphans","deepseq","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/time-compat-1.9.5/time-compat-1.9.5.tar.gz"},"name":"time-compat","pinned":{"url":["https://hackage.haskell.org/package/time-compat-1.9.5/time-compat-1.9.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/time-compat-1.9.5.tar.gz"],"sha256":"3126b267d19f31d52a3c36f13a8788be03242f829a5bddd8a3084e134d01e3a6","cabal-sha256":"a586bd5a59b47ea0c9eafc55c6936ede11126f4a6e619d6d7aeefee73c43d9b8"},"version":"1.9.5"}, "time-locale-compat": {"dependencies":["base","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/time-locale-compat-0.1.1.5/time-locale-compat-0.1.1.5.tar.gz"},"name":"time-locale-compat","pinned":{"url":["https://hackage.haskell.org/package/time-locale-compat-0.1.1.5/time-locale-compat-0.1.1.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/time-locale-compat-0.1.1.5.tar.gz"],"sha256":"07ff1566de7d851423a843b2de385442319348c621d4f779b3d365ce91ac502c","cabal-sha256":"24b10ab3de20f5fc00f0e4f7832ac66dd5597033b78cff3bd6b4505d8a652e5b"},"version":"0.1.1.5"}, @@ -274,7 +274,7 @@ "unbounded-delays": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unbounded-delays-0.1.1.1/unbounded-delays-0.1.1.1.tar.gz"},"name":"unbounded-delays","pinned":{"url":["https://hackage.haskell.org/package/unbounded-delays-0.1.1.1/unbounded-delays-0.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unbounded-delays-0.1.1.1.tar.gz"],"sha256":"59ad7e53bfe32ffbf0e703b31490d41d14c70e4745ed49e8adf592ed68dd6185","cabal-sha256":"d7a2a49f15bdff2a8bdbd76f9d204580ea4be5a9def500c6371d51d8111cbcbe"},"version":"0.1.1.1"}, "uniplate": {"dependencies":["base","containers","ghc-prim","hashable","syb","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/uniplate-1.6.13/uniplate-1.6.13.tar.gz"},"name":"uniplate","pinned":{"url":["https://hackage.haskell.org/package/uniplate-1.6.13/uniplate-1.6.13.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/uniplate-1.6.13.tar.gz"],"sha256":"e777c94628445556a71f135a42cf72d2cfbaccba5849cc42fbfec8b2182e3ad2","cabal-sha256":"c8b715570d0b4baa72512e677552dd3f98372a64bf9de000e779bd4162fd7be7"},"version":"1.6.13"}, "unix": {"dependencies":[],"location":{"type":"core"},"name":"unix","version":"2.7.2.2"}, - "unix-compat": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz"},"name":"unix-compat","pinned":{"url":["https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-compat-0.5.3.tar.gz"],"sha256":"0893b597ea0db406429d0d563506af6755728eface0e1981f9392122db88e5c8","cabal-sha256":"60be4a0b2e1cd873e5ad5f0cc9e53575b77640567abb43ef700d5b323ca2ac49"},"version":"0.5.3"}, + "unix-compat": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz"},"name":"unix-compat","pinned":{"url":["https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-compat-0.5.3.tar.gz"],"sha256":"0893b597ea0db406429d0d563506af6755728eface0e1981f9392122db88e5c8","cabal-sha256":"469cbd1399a7093c241cc9b99ff8ab8a259cb63326bf5c0a7d8448cb345d5e5a"},"version":"0.5.3"}, "unix-time": {"dependencies":["base","binary","bytestring","old-time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-time-0.4.7/unix-time-0.4.7.tar.gz"},"name":"unix-time","pinned":{"url":["https://hackage.haskell.org/package/unix-time-0.4.7/unix-time-0.4.7.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-time-0.4.7.tar.gz"],"sha256":"19233f8badf921d444c6165689253d877cfed58ce08f28cad312558a9280de09","cabal-sha256":"c0d971d04561875b908451c563df8728fe6d8639c90e070b244227f13f76ab8e"},"version":"0.4.7"}, "unliftio": {"dependencies":["async","base","bytestring","deepseq","directory","filepath","process","stm","time","transformers","unix","unliftio-core"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unliftio-0.2.18/unliftio-0.2.18.tar.gz"},"name":"unliftio","pinned":{"url":["https://hackage.haskell.org/package/unliftio-0.2.18/unliftio-0.2.18.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unliftio-0.2.18.tar.gz"],"sha256":"3ef4ed7a6d4f78a0c4dc21daba310953ad56619c355091d0e1ed923bb6e8e579","cabal-sha256":"87fb541127d21939d3efc49ed9bc3df6eadc9eb06ffa7755fc857f62e15daf20"},"version":"0.2.18"}, "unliftio-core": {"dependencies":["base","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz"},"name":"unliftio-core","pinned":{"url":["https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unliftio-core-0.2.0.1.tar.gz"],"sha256":"919f0d1297ea2f5373118553c1df2a9405d8b9e31a8307e829da67d4953c299a","cabal-sha256":"f9abcdd3f3d28e4840563efb7b8760d2de9b5707bcd6f53a87f6a0d77bb5a9f7"},"version":"0.2.0.1"}, diff --git a/stackage_snapshot_windows.json b/stackage_snapshot_windows.json index e6fe628f88..e91f2d6c0b 100644 --- a/stackage_snapshot_windows.json +++ b/stackage_snapshot_windows.json @@ -1,6 +1,6 @@ { - "__GENERATED_FILE_DO_NOT_MODIFY_MANUALLY": 2089110967, - "all-cabal-hashes": "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/97c141eb8342cb70c3944be892cc8cd98ef4886c", + "__GENERATED_FILE_DO_NOT_MODIFY_MANUALLY": 1898506442, + "all-cabal-hashes": "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/bac27a9f5d1c10d85f9301cdda0a3ba39bd8424d", "resolved": { "Cabal": {"dependencies":[],"location":{"type":"core"},"name":"Cabal","version":"3.2.1.0"}, "Decimal": {"dependencies":["base","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/Decimal-0.5.2/Decimal-0.5.2.tar.gz"},"name":"Decimal","pinned":{"url":["https://hackage.haskell.org/package/Decimal-0.5.2/Decimal-0.5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/Decimal-0.5.2.tar.gz"],"sha256":"a37a0220424e4bcb8cae1d38844c7027ee314449758d0d14ff3e2e0a5c8a87a7","cabal-sha256":"83dd16a1c0737fd35fdb1088af36e1a53034e75090e3f0d4ad32296f1a35a13b"},"version":"0.5.2"}, @@ -12,13 +12,13 @@ "StateVar": {"dependencies":["base","stm","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/StateVar-1.2.1/StateVar-1.2.1.tar.gz"},"name":"StateVar","pinned":{"url":["https://hackage.haskell.org/package/StateVar-1.2.1/StateVar-1.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/StateVar-1.2.1.tar.gz"],"sha256":"ee261552912b60d8b937f0253615e310e6cc25f9c407001b3bcc2e3d55000f8b","cabal-sha256":"b8bea664120dc78f5c15d9b8c0947d51dbc58a0b63ee49971fa7caac9f3e0845"},"version":"1.2.1"}, "Win32": {"dependencies":["base","bytestring","filepath"],"location":{"type":"core"},"name":"Win32","version":"2.6.1.0"}, "adjunctions": {"dependencies":["array","base","comonad","containers","contravariant","distributive","free","mtl","profunctors","semigroupoids","semigroups","tagged","transformers","transformers-compat","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz"},"name":"adjunctions","pinned":{"url":["https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/adjunctions-4.4.tar.gz"],"sha256":"507c2ef55337ae61c805f8cbc1213dfd7d2b85187342675d662254b8d8a16ae9","cabal-sha256":"2738dd5f5d5e93749adb14a05472e58a96a75d0f299e46371c6f46dc4e97daf9"},"version":"4.4"}, - "aeson": {"dependencies":["attoparsec","base","base-compat-batteries","bytestring","containers","data-fix","deepseq","dlist","ghc-prim","hashable","primitive","scientific","strict","tagged","template-haskell","text","th-abstraction","these","time","time-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz"},"name":"aeson","pinned":{"url":["https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-1.5.6.0.tar.gz"],"sha256":"0361c34be3d2ec945201f02501693436fbda10dcc549469481a084b2de22bfe8","cabal-sha256":"72c170b9fa0a4d1eaf47098902c621d0d95331cda1ebc4d86582bd557756b3ff"},"version":"1.5.6.0"}, + "aeson": {"dependencies":["attoparsec","base","base-compat-batteries","bytestring","containers","data-fix","deepseq","dlist","ghc-prim","hashable","primitive","scientific","strict","tagged","template-haskell","text","th-abstraction","these","time","time-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz"},"name":"aeson","pinned":{"url":["https://hackage.haskell.org/package/aeson-1.5.6.0/aeson-1.5.6.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-1.5.6.0.tar.gz"],"sha256":"0361c34be3d2ec945201f02501693436fbda10dcc549469481a084b2de22bfe8","cabal-sha256":"45d535d75041eccec635f31fd77d3af8f0682544153a67a569e3e8bad72bb023"},"version":"1.5.6.0"}, "aeson-compat": {"dependencies":["aeson","attoparsec","attoparsec-iso8601","base","base-compat","bytestring","containers","exceptions","hashable","scientific","tagged","text","time","time-locale-compat","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-compat-0.3.9/aeson-compat-0.3.9.tar.gz"},"name":"aeson-compat","pinned":{"url":["https://hackage.haskell.org/package/aeson-compat-0.3.9/aeson-compat-0.3.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-compat-0.3.9.tar.gz"],"sha256":"e043941ba761c13a3854fc087521b864b56b2df874154e42aedb67b2a77f23c8","cabal-sha256":"36cfb542fbcdf51584ec2d681869b3215cdfa1dd5e1040ae781ef8a271a54e95"},"version":"0.3.9"}, "aeson-extra": {"dependencies":["aeson","aeson-compat","attoparsec","attoparsec-iso8601","base","base-compat-batteries","bytestring","containers","deepseq","exceptions","hashable","parsec","recursion-schemes","scientific","semialign","template-haskell","text","these","time","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-extra-0.4.1.3/aeson-extra-0.4.1.3.tar.gz"},"name":"aeson-extra","pinned":{"url":["https://hackage.haskell.org/package/aeson-extra-0.4.1.3/aeson-extra-0.4.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-extra-0.4.1.3.tar.gz"],"sha256":"22e3e2b6d243fb9bc660899dbb677cb6f1f8c348cfc7464082b60ce3fcdc25cc","cabal-sha256":"8ad8e4d28e46280ea98af2e94dcaaf524c396c9d91b1eba867961efc6e7f923f"},"version":"0.4.1.3"}, "aeson-pretty": {"dependencies":["aeson","attoparsec","base","base-compat","bytestring","cmdargs","scientific","text","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz"},"name":"aeson-pretty","pinned":{"url":["https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-pretty-0.8.8.tar.gz"],"sha256":"81cea61cb6dcf32c3f0529ea5cfc98dbea3894152d7f2d9fe1cb051f927ec726","cabal-sha256":"6fcbe24e765457c81d1fc3b89d491bc7e37f7f6e12f0cdd1a3bbb1bacd712877"},"version":"0.8.8"}, "alex": {"dependencies":["array","base","containers","directory"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/alex-3.2.6/alex-3.2.6.tar.gz"},"name":"alex","pinned":{"url":["https://hackage.haskell.org/package/alex-3.2.6/alex-3.2.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/alex-3.2.6.tar.gz"],"sha256":"91aa08c1d3312125fbf4284815189299bbb0be34421ab963b1f2ae06eccc5410","cabal-sha256":"7e15b8ba44f4e858d7e302ae234c05ca10a120c401f0db5ea5bc6135347debca"},"version":"3.2.6"}, "ansi-terminal": {"dependencies":["Win32","base","colour","containers","mintty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-terminal-0.11/ansi-terminal-0.11.tar.gz"},"name":"ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/ansi-terminal-0.11/ansi-terminal-0.11.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-terminal-0.11.tar.gz"],"sha256":"c6611b9e51add41db3f79eac30066c06b33a6ca2a09e586b4b361d7f98303793","cabal-sha256":"97470250c92aae14c4c810d7f664c532995ba8910e2ad797b29f22ad0d2d0194"},"version":"0.11"}, - "ansi-wl-pprint": {"dependencies":["ansi-terminal","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz"},"name":"ansi-wl-pprint","pinned":{"url":["https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-wl-pprint-0.6.9.tar.gz"],"sha256":"a7b2e8e7cd3f02f2954e8b17dc60a0ccd889f49e2068ebb15abfa1d42f7a4eac","cabal-sha256":"20d30674f137d43aa0279c2c2cc5e45a5f1c3c57e301852494906158b6313bf7"},"version":"0.6.9"}, + "ansi-wl-pprint": {"dependencies":["ansi-terminal","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz"},"name":"ansi-wl-pprint","pinned":{"url":["https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-wl-pprint-0.6.9.tar.gz"],"sha256":"a7b2e8e7cd3f02f2954e8b17dc60a0ccd889f49e2068ebb15abfa1d42f7a4eac","cabal-sha256":"212144ea0623b1170807a4162db05d87f26cf10b334aeadd0edb377aba06a1ce"},"version":"0.6.9"}, "array": {"dependencies":[],"location":{"type":"core"},"name":"array","version":"0.5.4.0"}, "asn1-encoding": {"dependencies":["asn1-types","base","bytestring","hourglass"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/asn1-encoding-0.9.6/asn1-encoding-0.9.6.tar.gz"},"name":"asn1-encoding","pinned":{"url":["https://hackage.haskell.org/package/asn1-encoding-0.9.6/asn1-encoding-0.9.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/asn1-encoding-0.9.6.tar.gz"],"sha256":"d9f8deabd3b908e5cf83c0d813c08dc0143b3ec1c0d97f660d2cfa02c1c8da0a","cabal-sha256":"27ed8f6043aed79630313bb931f7c8e2b510f0b4586cd55c16ae040c7d1ea098"},"version":"0.9.6"}, "asn1-parse": {"dependencies":["asn1-encoding","asn1-types","base","bytestring"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/asn1-parse-0.9.5/asn1-parse-0.9.5.tar.gz"},"name":"asn1-parse","pinned":{"url":["https://hackage.haskell.org/package/asn1-parse-0.9.5/asn1-parse-0.9.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/asn1-parse-0.9.5.tar.gz"],"sha256":"8f1fe1344d30b39dc594d74df2c55209577722af1497204b4c2b6d6e8747f39e","cabal-sha256":"77c0126d63070df2d82cb4cfa4febb26c4e280f6d854bc778c2fa4d80ce692b8"},"version":"0.9.5"}, @@ -89,7 +89,7 @@ "either": {"dependencies":["base","bifunctors","mtl","profunctors","semigroupoids"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/either-5.0.1.1/either-5.0.1.1.tar.gz"},"name":"either","pinned":{"url":["https://hackage.haskell.org/package/either-5.0.1.1/either-5.0.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/either-5.0.1.1.tar.gz"],"sha256":"0243d51d6a02ecb541e4854a588a9b6219a4690ebcbdb79387dd14ad519cdf27","cabal-sha256":"41167573bf575b7e0e24283a52fba8ce7bed5a7cc2984bba0dce305a0ab66f0d"},"version":"5.0.1.1"}, "entropy": {"dependencies":["Cabal","Win32","base","bytestring","directory","filepath","process"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/entropy-0.4.1.6/entropy-0.4.1.6.tar.gz"},"name":"entropy","pinned":{"url":["https://hackage.haskell.org/package/entropy-0.4.1.6/entropy-0.4.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/entropy-0.4.1.6.tar.gz"],"sha256":"adc759ff756a6d71a450422ba511177632f43a33bf673901fd2334f53ef8bf62","cabal-sha256":"49ba23558a717d695724e5f10d9f4040f42db805a9fab774942c44c782f5de4b"},"version":"0.4.1.6"}, "exceptions": {"dependencies":["base","mtl","stm","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz"},"name":"exceptions","pinned":{"url":["https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/exceptions-0.10.4.tar.gz"],"sha256":"4d0bfb4355cffcd67d300811df9d5fe44ea3594ed63750795bfc1f797abd84cf","cabal-sha256":"d2546046d7ba4b460d3bc7fd269cd2c52d0b7fb3cfecc038715dd0881b78a484"},"version":"0.10.4"}, - "extra": {"dependencies":["base","clock","directory","filepath","process","semigroups","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz"},"name":"extra","pinned":{"url":["https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/extra-1.7.1.tar.gz"],"sha256":"a47f452a8b012973bff015facefff28d0bbc39910dadcaac9e1b35dbd2ee507f","cabal-sha256":"a9fd1d35a563820f414014f1659769f52726d2031eff6b4628abfcd86729a325"},"version":"1.7.1"}, + "extra": {"dependencies":["base","clock","directory","filepath","process","semigroups","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz"},"name":"extra","pinned":{"url":["https://hackage.haskell.org/package/extra-1.7.1/extra-1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/extra-1.7.1.tar.gz"],"sha256":"a47f452a8b012973bff015facefff28d0bbc39910dadcaac9e1b35dbd2ee507f","cabal-sha256":"f3a0e616bf7fd17f338668080d613a440f946a21d596f651552fcdf1dfc3c27e"},"version":"1.7.1"}, "fast-logger": {"dependencies":["array","auto-update","base","bytestring","directory","easy-file","filepath","text","unix-compat","unix-time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fast-logger-3.0.5/fast-logger-3.0.5.tar.gz"},"name":"fast-logger","pinned":{"url":["https://hackage.haskell.org/package/fast-logger-3.0.5/fast-logger-3.0.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fast-logger-3.0.5.tar.gz"],"sha256":"a693bfda13ea7220dc4d516134880bc0ba5652639f0d5148222f52640d5476d5","cabal-sha256":"fd430f998045aa86226faa29652ee797410a11edd9b77b709be1bedc96f77c4d"},"version":"3.0.5"}, "file-embed": {"dependencies":["base","bytestring","directory","filepath","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/file-embed-0.0.14.0/file-embed-0.0.14.0.tar.gz"},"name":"file-embed","pinned":{"url":["https://hackage.haskell.org/package/file-embed-0.0.14.0/file-embed-0.0.14.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/file-embed-0.0.14.0.tar.gz"],"sha256":"050267dbb2fb9033f16c66659fa739b6972775591fddf747e13f8d71c2f485ac","cabal-sha256":"41df92c8252b33957333fba5b4d3bfae2c6a35fc2582196fdb6a3618b41f5aaf"},"version":"0.0.14.0"}, "filelock": {"dependencies":["Win32","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/filelock-0.1.1.5/filelock-0.1.1.5.tar.gz"},"name":"filelock","pinned":{"url":["https://hackage.haskell.org/package/filelock-0.1.1.5/filelock-0.1.1.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/filelock-0.1.1.5.tar.gz"],"sha256":"50ebea81e8443356af26f32221d4594709d94102445931673fcd94a44e244419","cabal-sha256":"1d394c8ba29e410a57a451fbe6fc650d0392333b6b73ffc33afe1766f81c4486"},"version":"0.1.1.5"}, @@ -101,8 +101,8 @@ "generic-deriving": {"dependencies":["base","containers","ghc-prim","template-haskell","th-abstraction"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generic-deriving-1.14/generic-deriving-1.14.tar.gz"},"name":"generic-deriving","pinned":{"url":["https://hackage.haskell.org/package/generic-deriving-1.14/generic-deriving-1.14.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generic-deriving-1.14.tar.gz"],"sha256":"d0abd5e423960b66867c6149c20b221b1351e3805d1bf787fc4efa3e7bb7cb02","cabal-sha256":"c9c6782a3cdce2f2bcaf891e0ffbf06df871e68498574b73a565771dc084273c"},"version":"1.14"}, "generics-sop": {"dependencies":["base","ghc-prim","sop-core","template-haskell","th-abstraction"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generics-sop-0.5.1.1/generics-sop-0.5.1.1.tar.gz"},"name":"generics-sop","pinned":{"url":["https://hackage.haskell.org/package/generics-sop-0.5.1.1/generics-sop-0.5.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generics-sop-0.5.1.1.tar.gz"],"sha256":"81b7c38b5c2a1ae3c790b1707a0e2a2031430e33b3683f88e2daa5b59ae4c5d8","cabal-sha256":"522a1a1da05d5acc03da448fa603c038cc15b991272846a591e26e7505d2b73a"},"version":"0.5.1.1"}, "ghc-byteorder": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ghc-byteorder-4.11.0.0.10/ghc-byteorder-4.11.0.0.10.tar.gz"},"name":"ghc-byteorder","pinned":{"url":["https://hackage.haskell.org/package/ghc-byteorder-4.11.0.0.10/ghc-byteorder-4.11.0.0.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ghc-byteorder-4.11.0.0.10.tar.gz"],"sha256":"86e50a89798181db4f44ec3848fc52940c73098e88549a351ceb54fefc691fb6","cabal-sha256":"e345720de7b28ba1bf434775d34d3b94da8e8dd5dc24469f008e1f82717c0352"},"version":"4.11.0.0.10"}, - "ghc-lib": {"dependencies":["Win32","alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-lib-parser","ghc-prim","happy","hpc","pretty","process","rts","time","transformers"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-f1468b856c4a52a7826bfc0c29dee4f4.tar.gz"},"name":"ghc-lib","pinned":{"sha256":"f939726fdc6dbe67db4aeac86b3f6bcd88997dcb5648dc0d7e7f221760074165","strip-prefix":"ghc-lib-8.8.1.20211108"},"version":"8.8.1.20211108"}, - "ghc-lib-parser": {"dependencies":["Win32","alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-prim","happy","hpc","pretty","process","time","transformers"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-f1468b856c4a52a7826bfc0c29dee4f4.tar.gz"},"name":"ghc-lib-parser","pinned":{"sha256":"fbbca516fc2f8fab9d3095cde1edb98d3f05af9ea2dfb927275ed745b394685c","strip-prefix":"ghc-lib-parser-8.8.1.20211108"},"version":"8.8.1.20211108"}, + "ghc-lib": {"dependencies":["Win32","alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-lib-parser","ghc-prim","happy","hpc","pretty","process","rts","time","transformers"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-37eea5cf5534b712317d827ad081ca28.tar.gz"},"name":"ghc-lib","pinned":{"sha256":"719ff9dddcf74522a58edfed306f83303947f7bebb6453f55221203ff2692679","strip-prefix":"ghc-lib-8.8.1.20211118"},"version":"8.8.1.20211118"}, + "ghc-lib-parser": {"dependencies":["Win32","alex","array","base","binary","bytestring","containers","deepseq","directory","filepath","ghc-prim","happy","hpc","pretty","process","time","transformers"],"location":{"type":"archive","url":"https://daml-binaries.da-ext.net/da-ghc-lib/ghc-lib-parser-37eea5cf5534b712317d827ad081ca28.tar.gz"},"name":"ghc-lib-parser","pinned":{"sha256":"6361ac8a39088aa53478d5a6c878801e334e4c55309dc85360bdc6b2e5000335","strip-prefix":"ghc-lib-parser-8.8.1.20211118"},"version":"8.8.1.20211118"}, "ghc-lib-parser-ex": {"dependencies":["base","bytestring","containers","extra","ghc-lib-parser","uniplate"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ghc-lib-parser-ex-8.8.5.8/ghc-lib-parser-ex-8.8.5.8.tar.gz"},"name":"ghc-lib-parser-ex","pinned":{"url":["https://hackage.haskell.org/package/ghc-lib-parser-ex-8.8.5.8/ghc-lib-parser-ex-8.8.5.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ghc-lib-parser-ex-8.8.5.8.tar.gz"],"sha256":"b36ef8b49da4e8c78b00dca9b9546b7d4db0b09b10da5e313d3f0dbb4af581d7","cabal-sha256":"04f164fd6a4a5b0c5627cf7fadd79174c3b1d4c696dc481a9909266bd6a2a6aa"},"version":"8.8.5.8"}, "ghc-prim": {"dependencies":[],"location":{"type":"core"},"name":"ghc-prim","version":"0.6.1"}, "ghcide": {"dependencies":["aeson","async","base","binary","bytestring","containers","data-default","deepseq","dependent-map","dependent-sum","directory","extra","filepath","fuzzy","ghc-lib","ghc-lib-parser","haddock-library","hashable","hslogger","lsp","lsp-types","mtl","network-uri","prettyprinter","prettyprinter-ansi-terminal","regex-tdfa","rope-utf16-splay","safe-exceptions","shake","some","sorted-list","stm","syb","text","time","transformers","unliftio","unordered-containers","utf8-string"],"location":{"type":"vendored"},"name":"ghcide","version":"0.1.0"}, @@ -123,7 +123,7 @@ "hpc": {"dependencies":[],"location":{"type":"core"},"name":"hpc","version":"0.6.1.0"}, "hpp": {"dependencies":["base","bytestring","directory","filepath","ghc-prim","time","transformers","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hpp-0.6.3/hpp-0.6.3.tar.gz"},"name":"hpp","pinned":{"url":["https://hackage.haskell.org/package/hpp-0.6.3/hpp-0.6.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hpp-0.6.3.tar.gz"],"sha256":"7ac736cdc29799d196dbda74f0930cdeb3c526267798bbc261181053019cd53e","cabal-sha256":"d367b4803467c9a7817b4a4640f0d3d4b73269fd6d0dbf5dcda69e5a0938b2e2"},"version":"0.6.3"}, "hscolour": {"dependencies":["base","containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz"},"name":"hscolour","pinned":{"url":["https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hscolour-1.24.4.tar.gz"],"sha256":"243332b082294117f37b2c2c68079fa61af68b36223b3fc07594f245e0e5321d","cabal-sha256":"3a329fa0ea9138f651088f1fa25522aabeab0eb591932d3fd56c66736bbe78be"},"version":"1.24.4"}, - "hslogger": {"dependencies":["base","bytestring","containers","deepseq","network","network-bsd","old-locale","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz"},"name":"hslogger","pinned":{"url":["https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hslogger-1.3.1.0.tar.gz"],"sha256":"7f2364f6c0b9c5b85a257267a335816126ef2471c817a42797a5d3c57acaca5b","cabal-sha256":"b3fdd8c49c0c51adc9af8d7456e46ba580ad5ec478e18e92c3bb158d8ac38908"},"version":"1.3.1.0"}, + "hslogger": {"dependencies":["base","bytestring","containers","deepseq","network","network-bsd","old-locale","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz"},"name":"hslogger","pinned":{"url":["https://hackage.haskell.org/package/hslogger-1.3.1.0/hslogger-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hslogger-1.3.1.0.tar.gz"],"sha256":"7f2364f6c0b9c5b85a257267a335816126ef2471c817a42797a5d3c57acaca5b","cabal-sha256":"e40119589bc3299fe3f1ae84c067b0b056f96338b37daa19e6151d6233f9a2e1"},"version":"1.3.1.0"}, "hspec": {"dependencies":["QuickCheck","base","hspec-core","hspec-discover","hspec-expectations"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-2.7.10/hspec-2.7.10.tar.gz"},"name":"hspec","pinned":{"url":["https://hackage.haskell.org/package/hspec-2.7.10/hspec-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-2.7.10.tar.gz"],"sha256":"3c1bbda1962b2a493ad0bea0039720011948ac194c4c63d1c9f44d9c6be6147c","cabal-sha256":"c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce"},"version":"2.7.10"}, "hspec-core": {"dependencies":["HUnit","QuickCheck","ansi-terminal","array","base","call-stack","clock","deepseq","directory","filepath","hspec-expectations","quickcheck-io","random","setenv","stm","tf-random","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-core-2.7.10/hspec-core-2.7.10.tar.gz"},"name":"hspec-core","pinned":{"url":["https://hackage.haskell.org/package/hspec-core-2.7.10/hspec-core-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-core-2.7.10.tar.gz"],"sha256":"61d34e914b7c6bc01cac654de7bcb587f6b17969c0e49808512ddbffcaf5698a","cabal-sha256":"2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13"},"version":"2.7.10"}, "hspec-discover": {"dependencies":["base","directory","filepath"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-discover-2.7.10/hspec-discover-2.7.10.tar.gz"},"name":"hspec-discover","pinned":{"url":["https://hackage.haskell.org/package/hspec-discover-2.7.10/hspec-discover-2.7.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-discover-2.7.10.tar.gz"],"sha256":"0a576d00c67f1b093062130d0dcdaffb13c6812653db18f49e3a1db346dbdf8f","cabal-sha256":"d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f"},"version":"2.7.10"}, @@ -180,7 +180,7 @@ "optics-extra": {"dependencies":["array","base","bytestring","containers","hashable","indexed-profunctors","mtl","optics-core","text","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optics-extra-0.3/optics-extra-0.3.tar.gz"},"name":"optics-extra","pinned":{"url":["https://hackage.haskell.org/package/optics-extra-0.3/optics-extra-0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optics-extra-0.3.tar.gz"],"sha256":"a4d6155814111a5c6ce89640915ba5987296fec3cecc766ece3d4112abfd7697","cabal-sha256":"68c3dd038cb1b9a43107b645e33adfd14f085f5923ad01b42d222ee1b6aaa38f"},"version":"0.3"}, "optics-th": {"dependencies":["base","containers","mtl","optics-core","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optics-th-0.3.0.2/optics-th-0.3.0.2.tar.gz"},"name":"optics-th","pinned":{"url":["https://hackage.haskell.org/package/optics-th-0.3.0.2/optics-th-0.3.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optics-th-0.3.0.2.tar.gz"],"sha256":"80f0cbb1cda044631ef421a0112e2d9a9868c22d95e845d97902d0fbf822b1d7","cabal-sha256":"e786f290c237a3236eda8814957da882227c05ed063d865d4ab1af08d638244f"},"version":"0.3.0.2"}, "optional-args": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optional-args-1.0.2/optional-args-1.0.2.tar.gz"},"name":"optional-args","pinned":{"url":["https://hackage.haskell.org/package/optional-args-1.0.2/optional-args-1.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optional-args-1.0.2.tar.gz"],"sha256":"2e3454ad77cba80b15c02dbe1915889fafa81a22deb7fe5e7e01b0dd8d85b0e4","cabal-sha256":"83f6a4c838bf011e85ea5573bfd4d7f8a8516d97c64d07135b1713526135aa39"},"version":"1.0.2"}, - "optparse-applicative": {"dependencies":["ansi-wl-pprint","base","process","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz"},"name":"optparse-applicative","pinned":{"url":["https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-applicative-0.16.1.0.tar.gz"],"sha256":"6205278362f333c52256b9dd3edf5f8fe0f84f00cb9ee000291089f6eaccd69a","cabal-sha256":"16ebd7054b2265c1aad16c1d19dc503695fbfc67b35203d9952fd577d08c0110"},"version":"0.16.1.0"}, + "optparse-applicative": {"dependencies":["ansi-wl-pprint","base","process","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz"},"name":"optparse-applicative","pinned":{"url":["https://hackage.haskell.org/package/optparse-applicative-0.16.1.0/optparse-applicative-0.16.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-applicative-0.16.1.0.tar.gz"],"sha256":"6205278362f333c52256b9dd3edf5f8fe0f84f00cb9ee000291089f6eaccd69a","cabal-sha256":"418c22ed6a19124d457d96bc66bd22c93ac22fad0c7100fe4972bbb4ac989731"},"version":"0.16.1.0"}, "optparse-generic": {"dependencies":["Only","base","bytestring","optparse-applicative","system-filepath","text","time","transformers","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-generic-1.4.4/optparse-generic-1.4.4.tar.gz"},"name":"optparse-generic","pinned":{"url":["https://hackage.haskell.org/package/optparse-generic-1.4.4/optparse-generic-1.4.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-generic-1.4.4.tar.gz"],"sha256":"e44853c0a3def2556cec31337db411d6404d7f81d505662f8ebac68e119bc077","cabal-sha256":"3ad4624ae34193df88bee3d9af1f24e039482424d853fbbf854e7c711a41b5f8"},"version":"1.4.4"}, "parallel": {"dependencies":["array","base","containers","deepseq","ghc-prim"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz"},"name":"parallel","pinned":{"url":["https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parallel-3.2.2.0.tar.gz"],"sha256":"170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6","cabal-sha256":"19ff631f3a26ee7cf0603e2b80fc375d77d3f350ae460ae72fe4cf5da665c90b"},"version":"3.2.2.0"}, "parameterized": {"dependencies":["base","data-diverse","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parameterized-0.5.0.0/parameterized-0.5.0.0.tar.gz"},"name":"parameterized","pinned":{"url":["https://hackage.haskell.org/package/parameterized-0.5.0.0/parameterized-0.5.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parameterized-0.5.0.0.tar.gz"],"sha256":"d76bc473c671f3c448cc0683ec44f4495cb21938ab27a8e2c35a94683a373346","cabal-sha256":"880717fbb958de1bac015f0a375ab6636f162a72483d987a11e305da6fac6c97"},"version":"0.5.0.0"}, @@ -196,9 +196,9 @@ "prettyprinter": {"dependencies":["base","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-1.7.0/prettyprinter-1.7.0.tar.gz"},"name":"prettyprinter","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-1.7.0/prettyprinter-1.7.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-1.7.0.tar.gz"],"sha256":"591b87ce8a5cff39d66cb1c156c7d27d04de57952f16eb3ce3afe309ac26e0a7","cabal-sha256":"6a9569e21fa61163a7f066d23d701e23e917893e8f39733d6e617ec72787ae5f"},"version":"1.7.0"}, "prettyprinter-ansi-terminal": {"dependencies":["ansi-terminal","base","prettyprinter","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz"},"name":"prettyprinter-ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-ansi-terminal-1.1.2.tar.gz"],"sha256":"e26b7338b90830a126e210ec164426bd3da7d099a319d1287a40e3efce2a1799","cabal-sha256":"90b3b7650bc5b9f0e58da43621d23c817acfc0cf5ce71244b9bd11b8c9f95e3a"},"version":"1.1.2"}, "primes": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primes-0.2.1.0/primes-0.2.1.0.tar.gz"},"name":"primes","pinned":{"url":["https://hackage.haskell.org/package/primes-0.2.1.0/primes-0.2.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primes-0.2.1.0.tar.gz"],"sha256":"74d66558fb638ea4d31eae2fe1a294cb5a9d64491314305d74a11d93f277c65b","cabal-sha256":"94885df2e13153e439ca9c6eb1893726776ca7022128fe860278294bad49d6a9"},"version":"0.2.1.0"}, - "primitive": {"dependencies":["base","deepseq","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz"},"name":"primitive","pinned":{"url":["https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primitive-0.7.1.0.tar.gz"],"sha256":"6bebecfdf2a57787d9fd5231bfd612b65a92edd7b33a973b2a0f11312b89a3f0","cabal-sha256":"29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f"},"version":"0.7.1.0"}, + "primitive": {"dependencies":["base","deepseq","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz"},"name":"primitive","pinned":{"url":["https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primitive-0.7.1.0.tar.gz"],"sha256":"6bebecfdf2a57787d9fd5231bfd612b65a92edd7b33a973b2a0f11312b89a3f0","cabal-sha256":"cef1cfd0eade2be8e276520c897e20ebe3d4a7371d5a06c82648af4181cab326"},"version":"0.7.1.0"}, "process": {"dependencies":[],"location":{"type":"core"},"name":"process","version":"1.6.9.0"}, - "profunctors": {"dependencies":["base","base-orphans","bifunctors","comonad","contravariant","distributive","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz"},"name":"profunctors","pinned":{"url":["https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/profunctors-5.6.2.tar.gz"],"sha256":"65955d7b50525a4a3bccdab1d982d2ae342897fd38140d5a94b5ef3800d8c92a","cabal-sha256":"d91e81cf7fc186d616543d5ca7aad78b1c45c692486ca75a3f022466ff8e4bad"},"version":"5.6.2"}, + "profunctors": {"dependencies":["base","base-orphans","bifunctors","comonad","contravariant","distributive","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz"},"name":"profunctors","pinned":{"url":["https://hackage.haskell.org/package/profunctors-5.6.2/profunctors-5.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/profunctors-5.6.2.tar.gz"],"sha256":"65955d7b50525a4a3bccdab1d982d2ae342897fd38140d5a94b5ef3800d8c92a","cabal-sha256":"3d3685119243a7ebf984fa6af03299d156ab7674a432e2e15ecee2a4fd420fb6"},"version":"5.6.2"}, "proto3-suite": {"dependencies":["QuickCheck","aeson","aeson-pretty","attoparsec","base","base64-bytestring","binary","bytestring","cereal","containers","contravariant","deepseq","filepath","foldl","hashable","haskell-src","insert-ordered-containers","lens","mtl","neat-interpolation","optparse-applicative","optparse-generic","parsec","parsers","pretty","pretty-show","proto3-wire","quickcheck-instances","range-set-list","safe","swagger2","system-filepath","text","transformers","turtle","vector"],"location":{"type":"vendored"},"name":"proto3-suite","version":"0.4.2.0"}, "proto3-wire": {"dependencies":["QuickCheck","base","bytestring","cereal","containers","deepseq","ghc-prim","hashable","parameterized","primitive","safe","text","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/proto3-wire-1.2.0/proto3-wire-1.2.0.tar.gz"},"name":"proto3-wire","pinned":{"url":["https://hackage.haskell.org/package/proto3-wire-1.2.0/proto3-wire-1.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/proto3-wire-1.2.0.tar.gz"],"sha256":"625a7165ede6e348ac4a9474498879e0319d3b833dbdde9153865b6909cc36f7","cabal-sha256":"898c88614ef328fe74d6abc153387a30855af7ccfcebf3b419681133e0fb9291"},"version":"1.2.0"}, "quickcheck-instances": {"dependencies":["QuickCheck","array","base","bytestring","case-insensitive","containers","data-fix","hashable","integer-logarithms","old-time","scientific","splitmix","strict","tagged","text","these","time","time-compat","transformers","transformers-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/quickcheck-instances-0.3.25.2/quickcheck-instances-0.3.25.2.tar.gz"},"name":"quickcheck-instances","pinned":{"url":["https://hackage.haskell.org/package/quickcheck-instances-0.3.25.2/quickcheck-instances-0.3.25.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/quickcheck-instances-0.3.25.2.tar.gz"],"sha256":"70ccf54c6553d6a23b4ee48dc02f1e4120cbb9a609e03af073b93541b35a1846","cabal-sha256":"083b84b91fccb3bbf22cd906f5bc731c8e6ee96c7554e892985452f2d61d4ad3"},"version":"0.3.25.2"}, @@ -207,7 +207,7 @@ "range-set-list": {"dependencies":["base","containers","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/range-set-list-0.1.3.1/range-set-list-0.1.3.1.tar.gz"},"name":"range-set-list","pinned":{"url":["https://hackage.haskell.org/package/range-set-list-0.1.3.1/range-set-list-0.1.3.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/range-set-list-0.1.3.1.tar.gz"],"sha256":"12e8d9cb99a2847da32934ed7f44a5acedaa59d8fa19eff0f46aa77921460c55","cabal-sha256":"1bd9640aa97d8e1599a27a0f2e620040b4fdbc5cf2c5ff65efde0e2c18fd6521"},"version":"0.1.3.1"}, "recursion-schemes": {"dependencies":["base","base-orphans","comonad","containers","data-fix","free","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/recursion-schemes-5.2.2.1/recursion-schemes-5.2.2.1.tar.gz"},"name":"recursion-schemes","pinned":{"url":["https://hackage.haskell.org/package/recursion-schemes-5.2.2.1/recursion-schemes-5.2.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/recursion-schemes-5.2.2.1.tar.gz"],"sha256":"bee32985de5560ba69ef1503eff041091ddaffd68ba8ad736a8fcd95971f02db","cabal-sha256":"fed7167e83698147d7c078bbb1fe74451f96c7c55ed9986c734d268070d85864"},"version":"5.2.2.1"}, "refact": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/refact-0.3.0.2/refact-0.3.0.2.tar.gz"},"name":"refact","pinned":{"url":["https://hackage.haskell.org/package/refact-0.3.0.2/refact-0.3.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/refact-0.3.0.2.tar.gz"],"sha256":"0ad029727797c8ca5d179c7abf1bfc135d86a7d72cf93785ee12ad243aeb1f6c","cabal-sha256":"4ea82b93debdc0711e1bc4b5d8989b9e19613f369ff2049da33c5250b8d33bcd"},"version":"0.3.0.2"}, - "reflection": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz"},"name":"reflection","pinned":{"url":["https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reflection-2.1.6.tar.gz"],"sha256":"bf3e14917ebb329a53701a3cce0afe670f20037a0148dbfa5cbfa574ed6ba6cd","cabal-sha256":"044acb7caf41a9d8246878f849baed2dffbc4582d0a1e5c7c079d4287239e970"},"version":"2.1.6"}, + "reflection": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz"},"name":"reflection","pinned":{"url":["https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reflection-2.1.6.tar.gz"],"sha256":"bf3e14917ebb329a53701a3cce0afe670f20037a0148dbfa5cbfa574ed6ba6cd","cabal-sha256":"f41afef54a696377bb7591e12969a56e7a4a1cf1d2a32210ab24c6a7aa9bd7ae"},"version":"2.1.6"}, "regex-base": {"dependencies":["array","base","bytestring","containers","mtl","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/regex-base-0.94.0.0/regex-base-0.94.0.0.tar.gz"},"name":"regex-base","pinned":{"url":["https://hackage.haskell.org/package/regex-base-0.94.0.0/regex-base-0.94.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/regex-base-0.94.0.0.tar.gz"],"sha256":"c41f82f5fc1157c961a4cbdc0cd5561e5aa44f339ce6e706d978d97e0ca6b914","cabal-sha256":"44aa95ca762294ffbb28cf0af9c567d93b5d2c56e4f38ce5385a257d899f968e"},"version":"0.94.0.0"}, "regex-tdfa": {"dependencies":["array","base","bytestring","containers","mtl","parsec","regex-base","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/regex-tdfa-1.3.1.0/regex-tdfa-1.3.1.0.tar.gz"},"name":"regex-tdfa","pinned":{"url":["https://hackage.haskell.org/package/regex-tdfa-1.3.1.0/regex-tdfa-1.3.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/regex-tdfa-1.3.1.0.tar.gz"],"sha256":"15c376783d397b3b9933cf35980808feddde273bd6f2445babbccb2f76a42ec0","cabal-sha256":"eb8d0f007cf45faca8574f56f0d19c9b02bc529ef1688d8f8a9751ce7dc36cc3"},"version":"1.3.1.0"}, "repline": {"dependencies":["base","containers","exceptions","haskeline","mtl","process"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/repline-0.4.0.0/repline-0.4.0.0.tar.gz"},"name":"repline","pinned":{"url":["https://hackage.haskell.org/package/repline-0.4.0.0/repline-0.4.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/repline-0.4.0.0.tar.gz"],"sha256":"43c28c49c8e16276d32d0889f37f750d7c7a8d2758f1d35a9f36e68944e457b7","cabal-sha256":"3324479e497d27c40c3d4762bffc52058f9921621d20d2947dcf9a554b94cd0d"},"version":"0.4.0.0"}, @@ -219,7 +219,7 @@ "safe-exceptions": {"dependencies":["base","deepseq","exceptions","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/safe-exceptions-0.1.7.1/safe-exceptions-0.1.7.1.tar.gz"},"name":"safe-exceptions","pinned":{"url":["https://hackage.haskell.org/package/safe-exceptions-0.1.7.1/safe-exceptions-0.1.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/safe-exceptions-0.1.7.1.tar.gz"],"sha256":"4bf6dd0a2b18279be843ece044a89248553c092bb1fc5bd7efa55c1c1d537d3e","cabal-sha256":"ccf8dacc48a8fbc8450de9d3ae6f949067bb0c96d52bb66e3044b5cd046382d5"},"version":"0.1.7.1"}, "scientific": {"dependencies":["base","binary","bytestring","containers","deepseq","hashable","integer-gmp","integer-logarithms","primitive","template-haskell","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/scientific-0.3.7.0/scientific-0.3.7.0.tar.gz"},"name":"scientific","pinned":{"url":["https://hackage.haskell.org/package/scientific-0.3.7.0/scientific-0.3.7.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/scientific-0.3.7.0.tar.gz"],"sha256":"a3a121c4b3d68fb8b9f8c709ab012e48f090ed553609247a805ad070d6b343a9","cabal-sha256":"d7edb4dfb320e7b9cc9d503ca435d22983a236db06c7b4f3e81c099a9fd4cd73"},"version":"0.3.7.0"}, "semialign": {"dependencies":["base","containers","hashable","semigroupoids","tagged","these","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semialign-1.1.0.1/semialign-1.1.0.1.tar.gz"},"name":"semialign","pinned":{"url":["https://hackage.haskell.org/package/semialign-1.1.0.1/semialign-1.1.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semialign-1.1.0.1.tar.gz"],"sha256":"9810bddff641bf7446a1939e5f337e368f894d06e3995a536704b3e16b241a87","cabal-sha256":"44fa0af083af848efef9ac5c6cfa0d3a26fcb58d209942fae2ff941bf0f8cbe7"},"version":"1.1.0.1"}, - "semigroupoids": {"dependencies":["base","base-orphans","bifunctors","comonad","containers","contravariant","distributive","hashable","tagged","template-haskell","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz"},"name":"semigroupoids","pinned":{"url":["https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroupoids-5.3.5.tar.gz"],"sha256":"552f18e13ef347118911c950957e4adcda0a1f948e274f29ec449cc413d3c6b0","cabal-sha256":"e9ad7265a3baca520054fd2f9d6b1ebe6779502dc377550c99dee43e88555a8f"},"version":"5.3.5"}, + "semigroupoids": {"dependencies":["base","base-orphans","bifunctors","comonad","containers","contravariant","distributive","hashable","tagged","template-haskell","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz"},"name":"semigroupoids","pinned":{"url":["https://hackage.haskell.org/package/semigroupoids-5.3.5/semigroupoids-5.3.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroupoids-5.3.5.tar.gz"],"sha256":"552f18e13ef347118911c950957e4adcda0a1f948e274f29ec449cc413d3c6b0","cabal-sha256":"de84e651b967263a8348e18533bf02c9fd21fab83d8c041371dfcf61002bd436"},"version":"5.3.5"}, "semigroups": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz"},"name":"semigroups","pinned":{"url":["https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroups-0.19.1.tar.gz"],"sha256":"79e761e64b862564a3470d5d356cb6b060b14452d675859aed3b2d1e14646648","cabal-sha256":"aa5f4b64b0a440b6c7eb1a783a49484c0f169ae8bb08feeadbfe0e84556ca376"},"version":"0.19.1"}, "semver": {"dependencies":["attoparsec","base","deepseq","hashable","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semver-0.4.0.1/semver-0.4.0.1.tar.gz"},"name":"semver","pinned":{"url":["https://hackage.haskell.org/package/semver-0.4.0.1/semver-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semver-0.4.0.1.tar.gz"],"sha256":"7c47e326684efe407b2dc77924aa71c57c712465a9ed39c4097e6c1e1a1ff641","cabal-sha256":"a4f77491e1e7c8101e203748f6122918224590a44f81c39fefc62e27b448868d"},"version":"0.4.0.1"}, "setenv": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz"},"name":"setenv","pinned":{"url":["https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/setenv-0.1.1.3.tar.gz"],"sha256":"e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32","cabal-sha256":"c5916ac0d2a828473cd171261328a290afe0abd799db1ac8c310682fe778c45b"},"version":"0.1.1.3"}, @@ -237,7 +237,7 @@ "stm-chans": {"dependencies":["Cabal","base","stm"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz"},"name":"stm-chans","pinned":{"url":["https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/stm-chans-3.0.0.4.tar.gz"],"sha256":"2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738","cabal-sha256":"e2eef3cea5251628f7b2ad22c24a1e5d08b83c19be4bd886ab0d7fed58ef2a6d"},"version":"3.0.0.4"}, "stm-conduit": {"dependencies":["async","base","cereal","cereal-conduit","conduit","conduit-extra","directory","exceptions","monad-loops","resourcet","stm","stm-chans","transformers","unliftio"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/stm-conduit-4.0.1/stm-conduit-4.0.1.tar.gz"},"name":"stm-conduit","pinned":{"url":["https://hackage.haskell.org/package/stm-conduit-4.0.1/stm-conduit-4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/stm-conduit-4.0.1.tar.gz"],"sha256":"e80e5be72a4564fa45e1e27f91c0984e12d2a736d0ceb9594350d573efee1442","cabal-sha256":"71f477c617400fb5bee74557416d7dac17dccea0663ec29bf9ca67b52703637d"},"version":"4.0.1"}, "streaming-commons": {"dependencies":["Win32","array","async","base","bytestring","directory","filepath","network","process","random","stm","text","transformers","zlib"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/streaming-commons-0.2.2.1/streaming-commons-0.2.2.1.tar.gz"},"name":"streaming-commons","pinned":{"url":["https://hackage.haskell.org/package/streaming-commons-0.2.2.1/streaming-commons-0.2.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/streaming-commons-0.2.2.1.tar.gz"],"sha256":"306940bf4878a0b714e6746a7f934d018100efc86332c176a648014bfe1e81dd","cabal-sha256":"28abce35b48dcfb871926dad4cb37bdf737372892b4e5222abc97ca31f2ac738"},"version":"0.2.2.1"}, - "strict": {"dependencies":["assoc","base","binary","bytestring","deepseq","ghc-prim","hashable","text","these","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz"},"name":"strict","pinned":{"url":["https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/strict-0.4.0.1.tar.gz"],"sha256":"dff6abc08ad637e51891bb8b475778c40926c51219eda60fd64f0d9680226241","cabal-sha256":"ab041906af66c97de0ded33846865c9794c1a2cfce13d7e68e9b46922faf31ff"},"version":"0.4.0.1"}, + "strict": {"dependencies":["assoc","base","binary","bytestring","deepseq","ghc-prim","hashable","text","these","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz"},"name":"strict","pinned":{"url":["https://hackage.haskell.org/package/strict-0.4.0.1/strict-0.4.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/strict-0.4.0.1.tar.gz"],"sha256":"dff6abc08ad637e51891bb8b475778c40926c51219eda60fd64f0d9680226241","cabal-sha256":"ca6fba3bd2ddc0b70f31286192aa36359a99f1c0cd50e821ffc37bee772fd68f"},"version":"0.4.0.1"}, "swagger2": {"dependencies":["Cabal","QuickCheck","aeson","aeson-pretty","base","base-compat-batteries","bytestring","cabal-doctest","containers","cookie","generics-sop","hashable","http-media","insert-ordered-containers","lens","mtl","network","optics-core","optics-th","scientific","template-haskell","text","time","transformers","transformers-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/swagger2-2.6/swagger2-2.6.tar.gz"},"name":"swagger2","pinned":{"url":["https://hackage.haskell.org/package/swagger2-2.6/swagger2-2.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/swagger2-2.6.tar.gz"],"sha256":"682afe3b43d6b7c394cab330bb48692b8045dff8db3e8913bbfabee0fa8c706e","cabal-sha256":"12c0752b397da71e286a2f8998dfd842376df56f624deb0ad8d858c6e20cb8bd"},"version":"2.6"}, "syb": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/syb-0.7.2.1/syb-0.7.2.1.tar.gz"},"name":"syb","pinned":{"url":["https://hackage.haskell.org/package/syb-0.7.2.1/syb-0.7.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/syb-0.7.2.1.tar.gz"],"sha256":"1807c66f77e66786739387f0ae9f16d150d1cfa9d626afcb729f0e9b442a8d96","cabal-sha256":"bf42655a213402215299e435c52f799e76cbec0b984cd7153d6b9af8a1c0803f"},"version":"0.7.2.1"}, "system-fileio": {"dependencies":["Win32","base","bytestring","directory","system-filepath","text","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/system-fileio-0.3.16.4/system-fileio-0.3.16.4.tar.gz"},"name":"system-fileio","pinned":{"url":["https://hackage.haskell.org/package/system-fileio-0.3.16.4/system-fileio-0.3.16.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/system-fileio-0.3.16.4.tar.gz"],"sha256":"34e58b88a19a69ff1a559e211af6edb596e33ee1b1d5f44490febf325c78c6c7","cabal-sha256":"ca3a89469943828bcd526bed2d6943541e3e672464fd58abab3443b63f59c5ba"},"version":"0.3.16.4"}, @@ -261,7 +261,7 @@ "th-abstraction": {"dependencies":["base","containers","ghc-prim","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-abstraction-0.4.2.0/th-abstraction-0.4.2.0.tar.gz"},"name":"th-abstraction","pinned":{"url":["https://hackage.haskell.org/package/th-abstraction-0.4.2.0/th-abstraction-0.4.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-abstraction-0.4.2.0.tar.gz"],"sha256":"ea06b2cda25fc4b52dac48cc23e5a756f997df8985ecaee5a554202508a11c40","cabal-sha256":"6ba7b201931f614173755f060fdf98f02095df68c1f7bc3e2691cf9d443e81f9"},"version":"0.4.2.0"}, "th-compat": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-compat-0.1.2/th-compat-0.1.2.tar.gz"},"name":"th-compat","pinned":{"url":["https://hackage.haskell.org/package/th-compat-0.1.2/th-compat-0.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-compat-0.1.2.tar.gz"],"sha256":"2bc45d0199de3dc65ebc9b71251799f5238869dbc6a66bdf0c06c7e23d603801","cabal-sha256":"3d55de1adc542c1a870c9ada90da2fbbe5f4e8bcd3eed545a55c3df9311b32a8"},"version":"0.1.2"}, "th-extras": {"dependencies":["base","syb","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-extras-0.0.0.4/th-extras-0.0.0.4.tar.gz"},"name":"th-extras","pinned":{"url":["https://hackage.haskell.org/package/th-extras-0.0.0.4/th-extras-0.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-extras-0.0.0.4.tar.gz"],"sha256":"8feff450aaf28ec4f08c45a5656c62879861a8e7f45591cb367d5351ddc3fbed","cabal-sha256":"2f408c0f427530f36beb19c733a7a57f67b727713f9bb942b64f3b2e0e2932bf"},"version":"0.0.0.4"}, - "these": {"dependencies":["assoc","base","binary","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz"},"name":"these","pinned":{"url":["https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/these-1.1.1.1.tar.gz"],"sha256":"d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508","cabal-sha256":"2deb8cb10e5ad68b073509c29b2aebd25bf59149b5bb8b3b38b2c6109802725d"},"version":"1.1.1.1"}, + "these": {"dependencies":["assoc","base","binary","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz"},"name":"these","pinned":{"url":["https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/these-1.1.1.1.tar.gz"],"sha256":"d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508","cabal-sha256":"f069e766b8fed73d457fca20cc197f5c539bcdd03d7636e478ddf14dbb67684a"},"version":"1.1.1.1"}, "time": {"dependencies":[],"location":{"type":"core"},"name":"time","version":"1.9.3"}, "time-compat": {"dependencies":["base","base-orphans","deepseq","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/time-compat-1.9.5/time-compat-1.9.5.tar.gz"},"name":"time-compat","pinned":{"url":["https://hackage.haskell.org/package/time-compat-1.9.5/time-compat-1.9.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/time-compat-1.9.5.tar.gz"],"sha256":"3126b267d19f31d52a3c36f13a8788be03242f829a5bddd8a3084e134d01e3a6","cabal-sha256":"a586bd5a59b47ea0c9eafc55c6936ede11126f4a6e619d6d7aeefee73c43d9b8"},"version":"1.9.5"}, "time-locale-compat": {"dependencies":["base","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/time-locale-compat-0.1.1.5/time-locale-compat-0.1.1.5.tar.gz"},"name":"time-locale-compat","pinned":{"url":["https://hackage.haskell.org/package/time-locale-compat-0.1.1.5/time-locale-compat-0.1.1.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/time-locale-compat-0.1.1.5.tar.gz"],"sha256":"07ff1566de7d851423a843b2de385442319348c621d4f779b3d365ce91ac502c","cabal-sha256":"24b10ab3de20f5fc00f0e4f7832ac66dd5597033b78cff3bd6b4505d8a652e5b"},"version":"0.1.1.5"}, @@ -274,7 +274,7 @@ "typed-process": {"dependencies":["async","base","bytestring","process","stm","transformers","unliftio-core"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/typed-process-0.2.6.0/typed-process-0.2.6.0.tar.gz"},"name":"typed-process","pinned":{"url":["https://hackage.haskell.org/package/typed-process-0.2.6.0/typed-process-0.2.6.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/typed-process-0.2.6.0.tar.gz"],"sha256":"31a2a81f33463fedc33cc519ad5b9679787e648fe2ec7efcdebd7d54bdbbc2b1","cabal-sha256":"c901c13d491441830eb23132ad6968243a56b98161629d260a26c0b13c735fcd"},"version":"0.2.6.0"}, "unbounded-delays": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unbounded-delays-0.1.1.1/unbounded-delays-0.1.1.1.tar.gz"},"name":"unbounded-delays","pinned":{"url":["https://hackage.haskell.org/package/unbounded-delays-0.1.1.1/unbounded-delays-0.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unbounded-delays-0.1.1.1.tar.gz"],"sha256":"59ad7e53bfe32ffbf0e703b31490d41d14c70e4745ed49e8adf592ed68dd6185","cabal-sha256":"d7a2a49f15bdff2a8bdbd76f9d204580ea4be5a9def500c6371d51d8111cbcbe"},"version":"0.1.1.1"}, "uniplate": {"dependencies":["base","containers","ghc-prim","hashable","syb","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/uniplate-1.6.13/uniplate-1.6.13.tar.gz"},"name":"uniplate","pinned":{"url":["https://hackage.haskell.org/package/uniplate-1.6.13/uniplate-1.6.13.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/uniplate-1.6.13.tar.gz"],"sha256":"e777c94628445556a71f135a42cf72d2cfbaccba5849cc42fbfec8b2182e3ad2","cabal-sha256":"c8b715570d0b4baa72512e677552dd3f98372a64bf9de000e779bd4162fd7be7"},"version":"1.6.13"}, - "unix-compat": {"dependencies":["Win32","base","directory","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz"},"name":"unix-compat","pinned":{"url":["https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-compat-0.5.3.tar.gz"],"sha256":"0893b597ea0db406429d0d563506af6755728eface0e1981f9392122db88e5c8","cabal-sha256":"60be4a0b2e1cd873e5ad5f0cc9e53575b77640567abb43ef700d5b323ca2ac49"},"version":"0.5.3"}, + "unix-compat": {"dependencies":["Win32","base","directory","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz"},"name":"unix-compat","pinned":{"url":["https://hackage.haskell.org/package/unix-compat-0.5.3/unix-compat-0.5.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-compat-0.5.3.tar.gz"],"sha256":"0893b597ea0db406429d0d563506af6755728eface0e1981f9392122db88e5c8","cabal-sha256":"469cbd1399a7093c241cc9b99ff8ab8a259cb63326bf5c0a7d8448cb345d5e5a"},"version":"0.5.3"}, "unix-time": {"dependencies":["base","binary","bytestring","old-time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unix-time-0.4.7/unix-time-0.4.7.tar.gz"},"name":"unix-time","pinned":{"url":["https://hackage.haskell.org/package/unix-time-0.4.7/unix-time-0.4.7.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unix-time-0.4.7.tar.gz"],"sha256":"19233f8badf921d444c6165689253d877cfed58ce08f28cad312558a9280de09","cabal-sha256":"c0d971d04561875b908451c563df8728fe6d8639c90e070b244227f13f76ab8e"},"version":"0.4.7"}, "unliftio": {"dependencies":["async","base","bytestring","deepseq","directory","filepath","process","stm","time","transformers","unliftio-core"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unliftio-0.2.18/unliftio-0.2.18.tar.gz"},"name":"unliftio","pinned":{"url":["https://hackage.haskell.org/package/unliftio-0.2.18/unliftio-0.2.18.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unliftio-0.2.18.tar.gz"],"sha256":"3ef4ed7a6d4f78a0c4dc21daba310953ad56619c355091d0e1ed923bb6e8e579","cabal-sha256":"87fb541127d21939d3efc49ed9bc3df6eadc9eb06ffa7755fc857f62e15daf20"},"version":"0.2.18"}, "unliftio-core": {"dependencies":["base","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz"},"name":"unliftio-core","pinned":{"url":["https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unliftio-core-0.2.0.1.tar.gz"],"sha256":"919f0d1297ea2f5373118553c1df2a9405d8b9e31a8307e829da67d4953c299a","cabal-sha256":"f9abcdd3f3d28e4840563efb7b8760d2de9b5707bcd6f53a87f6a0d77bb5a9f7"},"version":"0.2.0.1"}, diff --git a/triggers/tests/daml/Interface.daml b/triggers/tests/daml/Interface.daml index 9133b6e606..f387593ff8 100644 --- a/triggers/tests/daml/Interface.daml +++ b/triggers/tests/daml/Interface.daml @@ -20,7 +20,7 @@ test = Trigger with dedupCreate Asset {owner = p1, issuer = p1, amount = 10} cs -> do forA_ cs $ \(cid, _asset) -> do - dedupExercise (toTokenContractId cid) $ Transfer with newOwner = p1 + dedupExercise (toInterfaceContractId @_ @Token cid) $ Transfer with newOwner = p1 registeredTemplates = AllInDar heartbeat = None @@ -68,11 +68,11 @@ template Asset assert (splitAmount < amount) cid1 <- create this with amount = splitAmount cid2 <- create this with amount = amount - splitAmount - pure (toTokenContractId cid1, toTokenContractId cid2) + pure (toInterfaceContractId @_ @Token cid1, toInterfaceContractId @_ @Token cid2) let transferImpl = \newOwner -> do cid <- create this with owner = newOwner - pure (toTokenContractId cid) + pure (toInterfaceContractId @_ @Token cid) let noopImpl = \nothing -> do pure ()