Generate protocolUpdateUtxoCostPerByte in genProtocolParametersUpdate era dependently

[newhoggy]

Depends on #5069

[Jimbo4350]

So we actually explicitly avoided using GADTs for ProtocolParameter fields because it would result in an explosion of type definitions.

[newhoggy]

I added GADTs because that was the way we handle era support for things that aren't protocol parameters.

The cost will be (2 x numEras + 5) x numRelevantProtocolPameters. I don't yet have a good idea how many protocol parameters need this. At least each new protocol parameter will need this.

The ability to determine what protocol parameters are available for what era will be important to generators but I also suspect users of our API will find this useful too.

As for what alternative solutions are available, it will need to be one that allows us to express both the addition and removal of protocol parameters because new eras can and have removed protocol parameters.

If not expressed as types it could be expressed as a runtime value.

[newhoggy]

For comparison:

• Number of features: 24
• Number of protocol parameters: 25

[newhoggy]

I've updated PR with an more concise encoding. This means we write less code when adding a new parameter or feature.

We could also convert the existing feature supported in era code to use this new system instead which would reduce the amount of code.

[newhoggy]

This module introduces a new unified type-safe era-based feature flag system.

[newhoggy]

Each new feature is represented as an un-exported type.

[carbolymer]

Maybe DataKinds would be better here to have a single kind for them?

[newhoggy]

The Feature GADT has a constructor for each feature. This type is exported rather than the individual feature types.

[newhoggy]

Unifying the features into one type means we only need type class instances for the Feature type and not for each feature type.

[newhoggy]

The SupportedInEra type allows us to only add code for when a feature is supported in an era. We don't have to add the negative cases.

[carbolymer]

It's a just a cartesian product of eras and features in a form of a constructor for each, so it will be cumbersome to maintain I think. How about just a type class?

data ByronEra
data ShelleyEra
data AllegraEra
data MaryEra
data AlonzoEra
data BabbageEra
data ConwayEra

-- This can be turned into a single datatype using DataKinds
data ProtocolParameterUTxOCostPerWord
data ProtocolParameterUTxOCostPerByte
data UnknownFeature

data CardanoEra era where
     ByronEra   :: CardanoEra ByronEra
     ShelleyEra :: CardanoEra ShelleyEra
     AllegraEra :: CardanoEra AllegraEra
     MaryEra    :: CardanoEra MaryEra
     AlonzoEra  :: CardanoEra AlonzoEra
     BabbageEra :: CardanoEra BabbageEra
     ConwayEra  :: CardanoEra ConwayEra


data Feature f where
  ProtocolParameterUTxOCostPerWord :: Feature ProtocolParameterUTxOCostPerWord
  ProtocolParameterUTxOCostPerByte :: Feature ProtocolParameterUTxOCostPerByte
  UnknownFeature :: Feature UnknownFeature

class SupportedInEra f e where
  supportedInEra :: Feature f -> CardanoEra e -> Bool

instance {-# OVERLAPPABLE #-} SupportedInEra f e where
  supportedInEra _ _ = False

instance ProtocolParameterUTxOCostPerWord `SupportedInEra` ByronEra where
  supportedInEra _ _ = True

instance SupportedInEra ProtocolParameterUTxOCostPerByte ByronEra where
  supportedInEra _ _ = True

-- >>> supportedInEra ProtocolParameterUTxOCostPerWord ByronEra
-- True

-- >>> supportedInEra ProtocolParameterUTxOCostPerByte ByronEra
-- True

-- >>> supportedInEra UnknownFeature ByronEra
-- False

-- This can be simplified further with a phantom type, not requiring to create a new constructor for each
-- feature, which is already a type
data Feature' f = Feature'

class SupportedInEra' f e where
  supportedInEra' :: Feature' f -> CardanoEra e -> Bool

instance {-# OVERLAPPABLE #-} SupportedInEra' f e where
  supportedInEra' _ _ = False

instance SupportedInEra' ProtocolParameterUTxOCostPerWord ByronEra where
  supportedInEra' _ _ = True

instance SupportedInEra' ProtocolParameterUTxOCostPerByte ByronEra where
  supportedInEra' _ _ = True


-- >>> supportedInEra' (Feature' @ProtocolParameterUTxOCostPerByte) ByronEra
-- True

-- >>> supportedInEra' (Feature' @ProtocolParameterUTxOCostPerByte) ByronEra
-- True

-- >>> supportedInEra' (Feature' @UnknownFeature) ByronEra
-- False

we can simplify this even further with {-# LANGUAGE AllowAmbiguousTypes #-}:

class SupportedInEra'' f e where
  supportedInEra'' :: Bool

instance {-# OVERLAPPABLE #-} SupportedInEra'' a b where
  supportedInEra'' = False
instance  SupportedInEra'' ProtocolParameterUTxOCostPerByte ByronEra where
  supportedInEra'' = True

-- >>> supportedInEra'' @UnknownFeature @ByronEra
-- False

-- >>> supportedInEra'' @ProtocolParameterUTxOCostPerByte @ByronEra
-- True

Do we need features to be types?

[newhoggy]

The supportedInEra type allows us to only add code for when a feature is supported in an era. We don't have to add the negative cases.

[newhoggy]

An example of how supportedInEra is used.