ouroboros-network-protocols: type signatures

* Provide kinds for some of the type variables.  This improves haddocks.
* Added export list for `PeerSharing.Codec`
* Not exporting `encodeTxSubmission2` and `decodeTxSubmission2`, they
  are not used outside of this module, and they are not used in
  `ouroboros-consensus`.

Author: coot

ouroboros-network-protocols/src/Ouroboros/Network/Protocol/BlockFetch/Codec.hs

@@ -1,7 +1,6 @@
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE GADTs               #-}
-{-# LANGUAGE NamedFieldPuns      #-}
 {-# LANGUAGE PolyKinds           #-}
 {-# LANGUAGE RankNTypes          #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -18,19 +17,20 @@ import Control.Monad.Class.MonadST
 import Control.Monad.Class.MonadTime.SI
 
 import Data.ByteString.Lazy qualified as LBS
+import Data.Kind (Type)
 
 import Codec.CBOR.Decoding qualified as CBOR
 import Codec.CBOR.Encoding qualified as CBOR
 import Codec.CBOR.Read qualified as CBOR
 import Text.Printf
 
-import Network.TypedProtocol.Codec.CBOR
+import Network.TypedProtocol.Codec.CBOR hiding (decode, encode)
 
 import Ouroboros.Network.Protocol.BlockFetch.Type
 import Ouroboros.Network.Protocol.Limits
 
 -- | Byte Limit.
-byteLimitsBlockFetch :: forall bytes block point.
+byteLimitsBlockFetch :: forall bytes (block :: Type) (point :: Type).
                         (bytes -> Word) -- ^ compute size of bytes
                      -> ProtocolSizeLimits (BlockFetch block point) bytes
 byteLimitsBlockFetch = ProtocolSizeLimits stateToLimit
@@ -54,6 +54,7 @@ byteLimitsBlockFetch = ProtocolSizeLimits stateToLimit
 -- | `BFStreaming`    | `longWait`    |
 -- +------------------+---------------+
 --
+timeLimitsBlockFetch :: forall (block :: Type) (point :: Type).
                         ProtocolTimeLimits (BlockFetch block point)
 timeLimitsBlockFetch = ProtocolTimeLimits stateToLimit
   where
@@ -138,7 +139,7 @@ codecBlockFetch encodeBlock decodeBlock
 
 
 codecBlockFetchId
-  :: forall block point m.
+  :: forall (block :: Type) (point :: Type) m.
      Monad m
   => Codec (BlockFetch block point) CodecFailure m
            (AnyMessage (BlockFetch block point))

ouroboros-network-protocols/src/Ouroboros/Network/Protocol/ChainSync/Codec.hs

@@ -23,6 +23,7 @@ import Ouroboros.Network.Protocol.ChainSync.Type
 import Ouroboros.Network.Protocol.Limits
 
 import Data.ByteString.Lazy qualified as LBS
+import Data.Kind (Type)
 import Data.Singletons (withSingI)
 import System.Random (StdGen, randomR)
 
@@ -78,7 +79,7 @@ maxChainSyncTimeout = 269
 -- | @'StIntersect'@            | 'shortWait'                                                 |
 -- +----------------------------+-------------------------------------------------------------+
 --
-timeLimitsChainSync :: forall header point tip.
+timeLimitsChainSync :: forall (header :: Type) (point :: Type) (tip :: Type).
                        StdGen
                     -> ProtocolTimeLimits (ChainSync header point tip)
 timeLimitsChainSync rnd = ProtocolTimeLimits stateToLimit

ouroboros-network-protocols/src/Ouroboros/Network/Protocol/PeerSharing/Codec.hs

@@ -6,12 +6,18 @@
 {-# LANGUAGE RankNTypes          #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
-module Ouroboros.Network.Protocol.PeerSharing.Codec where
+module Ouroboros.Network.Protocol.PeerSharing.Codec
+  ( codecPeerSharing
+  , codecPeerSharingId
+  , byteLimitsPeerSharing
+  , timeLimitsPeerSharing
+  ) where
 
 import Control.Monad.Class.MonadST
 import Control.Monad.Class.MonadTime.SI (DiffTime)
 
 import Data.ByteString.Lazy (ByteString)
+import Data.Kind (Type)
 
 import Codec.CBOR.Decoding qualified as CBOR
 import Codec.CBOR.Encoding qualified as CBOR
@@ -23,7 +29,7 @@ import Network.TypedProtocol.Codec.CBOR
 import Ouroboros.Network.Protocol.Limits
 import Ouroboros.Network.Protocol.PeerSharing.Type
 
-codecPeerSharing :: forall m peerAddress.
+codecPeerSharing :: forall m (peerAddress :: Type).
                     MonadST m
                  => (peerAddress -> CBOR.Encoding)
                  -- ^ encode 'peerAddress'
@@ -87,7 +93,7 @@ codecPeerSharing encodeAddress decodeAddress = mkCodecCborLazyBS encodeMsg decod
           Just n  -> CBOR.decodeSequenceLenN     (flip (:)) [] reverse n dec
 
 codecPeerSharingId
-  :: forall peerAddress m.
+  :: forall (peerAddress :: Type) m.
      Monad m
   => Codec (PeerSharing peerAddress) CodecFailure m (AnyMessage (PeerSharing peerAddress))
 codecPeerSharingId = Codec encodeMsg decodeMsg
@@ -121,7 +127,7 @@ codecPeerSharingId = Codec encodeMsg decodeMsg
 maxTransmissionUnit :: Word
 maxTransmissionUnit = 4 * 1440
 
-byteLimitsPeerSharing :: forall peerAddress bytes.
+byteLimitsPeerSharing :: forall (peerAddress :: Type) bytes.
                          (bytes -> Word) -- ^ compute size of bytes
                       -> ProtocolSizeLimits (PeerSharing peerAddress) bytes
 byteLimitsPeerSharing = ProtocolSizeLimits sizeLimitForState
@@ -144,6 +150,7 @@ byteLimitsPeerSharing = ProtocolSizeLimits sizeLimitForState
 -- | `StBusy`             | `longWait`    |
 -- +----------------------+---------------+
 --
+timeLimitsPeerSharing :: forall (peerAddress :: Type). ProtocolTimeLimits (PeerSharing peerAddress)
 timeLimitsPeerSharing = ProtocolTimeLimits { timeLimitForState }
   where
     timeLimitForState :: forall (st :: PeerSharing peerAddress).

ouroboros-network-protocols/src/Ouroboros/Network/Protocol/TxSubmission2/Codec.hs

@@ -10,21 +10,20 @@
 module Ouroboros.Network.Protocol.TxSubmission2.Codec
   ( codecTxSubmission2
   , codecTxSubmission2Id
-  , encodeTxSubmission2
-  , decodeTxSubmission2
   , byteLimitsTxSubmission2
   , timeLimitsTxSubmission2
   ) where
 
 import Control.Monad.Class.MonadST
 import Control.Monad.Class.MonadTime.SI
+import Data.ByteString.Lazy (ByteString)
+import Data.Kind (Type)
 import Data.List.NonEmpty qualified as NonEmpty
+import Text.Printf
 
 import Codec.CBOR.Decoding qualified as CBOR
 import Codec.CBOR.Encoding qualified as CBOR
 import Codec.CBOR.Read qualified as CBOR
-import Data.ByteString.Lazy (ByteString)
-import Text.Printf
 
 import Network.TypedProtocol.Codec.CBOR
 
@@ -63,6 +62,7 @@ byteLimitsTxSubmission2 = ProtocolSizeLimits stateToLimit
 -- | `StTxs`                     | `shortWait`   |
 -- +-----------------------------+---------------+
 --
+timeLimitsTxSubmission2 :: forall (txid :: Type) (tx :: Type). ProtocolTimeLimits (TxSubmission2 txid tx)
 timeLimitsTxSubmission2 = ProtocolTimeLimits stateToLimit
   where
     stateToLimit :: forall (st :: TxSubmission2 txid tx).
@@ -76,7 +76,7 @@ timeLimitsTxSubmission2 = ProtocolTimeLimits stateToLimit
 
 
 codecTxSubmission2
-  :: forall txid tx m.
+  :: forall (txid :: Type) (tx :: Type) m.
      MonadST m
   => (txid -> CBOR.Encoding)
   -- ^ encode 'txid'
@@ -103,7 +103,7 @@ codecTxSubmission2 encodeTxId decodeTxId
       decodeTxSubmission2 decodeTxId decodeTx stok len key
 
 encodeTxSubmission2
-    :: forall txid tx (st :: TxSubmission2 txid tx) (st' :: TxSubmission2 txid tx).
+    :: forall (txid :: Type) (tx :: Type) (st :: TxSubmission2 txid tx) (st' :: TxSubmission2 txid tx).
        (txid -> CBOR.Encoding)
     -- ^ encode 'txid'
     -> (tx -> CBOR.Encoding)