I have determined (by analyzing all the .hs files) that for weeks 1-8, the following modules are variously imported:

import qualified Prelude
import qualified Prelude                       as P
import           Prelude                       (IO)
import           Prelude                       (IO, Show (..))
import           Prelude                       (IO, Show (..), String)
import           Prelude                       (IO, Semigroup (..), String)
import           Prelude                       (IO, Semigroup (..), String, undefined)
import           Prelude                       (IO, Semigroup (..), Show (..), String)
import           Prelude                       (IO, Semigroup (..), Show (..), String, undefined)
import           Prelude                       (Semigroup (..), Show (..), String)
import           Prelude                       (Semigroup (..), Show (..), uncurry)

import           Cardano.Api
import           Cardano.Api                   as API
import           Cardano.Api.Shelley           (PlutusScript (..))
import           Cardano.Api.Shelley           (Address (..), PlutusScript (..))
import           Cardano.Crypto.Hash.Class     (hashToBytes)
import           Cardano.Ledger.Credential     as Ledger
import           Cardano.Ledger.Crypto         (StandardCrypto)
import           Cardano.Ledger.Hashes         (ScriptHash (..))
import           Cardano.Ledger.Keys           (KeyHash (..))

import           Codec.Serialise               (serialise)

import           Control.Lens
import           Control.Monad
import           Control.Monad                 hiding (fmap)
import           Control.Monad.Freer.Extras    as Extras

import           Data.Aeson                    (ToJSON, FromJSON)
import           Data.Aeson                    (encode)
import qualified Data.ByteString.Char8         as BS8
import qualified Data.ByteString.Lazy          as LBS
import qualified Data.ByteString.Short         as SBS
import           Data.Default                  (Default (..))
import           Data.Functor                  (void)
import           Data.List.NonEmpty            (NonEmpty (..))
import           Data.Map                      as Map
import qualified Data.Map                      as Map
import           Data.Maybe                    (fromJust, fromMaybe)
import           Data.Monoid                   (Last (..))
import           Data.OpenApi.Schema           (ToSchema)
import           Data.String                   (IsString (..))
import           Data.Text                     (Text)
import           Data.Text                     (pack, Text)
import           Data.Text                     (Text, unpack)
import           Data.Void                     (Void)

import           GHC.Generics                  (Generic)

import           Ledger
import qualified Ledger
import qualified Ledger                        as Plutus
import           Ledger                        hiding (singleton)
import           Ledger                        hiding (mint, singleton)
import           Ledger                        (Address)
import           Ledger.Ada                    as Ada
import           Ledger.Constraints            as Constraints
import qualified Ledger.Constraints            as Constraints
import           Ledger.Constraints            (TxConstraints)
import qualified Ledger.Scripts                as Scripts
import qualified Ledger.Scripts                as Scripts hiding (validatorHash)
import           Ledger.TimeSlot
import qualified Ledger.Typed.Scripts          as Scripts
import           Ledger.Typed.Tx
import           Ledger.Value
import           Ledger.Value                  as Value

import           Playground.Contract         (IO, ensureKnownCurrencies, printSchemas, stage, printJson)
import           Playground.Contract         (printJson, printSchemas, ensureKnownCurrencies, stage)
import           Playground.Contract         (printJson, printSchemas, ensureKnownCurrencies, stage, ToSchema)
import           Playground.Contract         (ToSchema)
import           Playground.TH               (mkKnownCurrencies, mkSchemaDefinitions)
import           Playground.Types            (KnownCurrency (..))

import           Plutus.Contract
import           Plutus.Contract               as Contract
import           Plutus.Contract.StateMachine
import           Plutus.PAB.Effects.Contract.Builtin (Empty, HasDefinitions (..), SomeBuiltin (..), endpointsToSchemas)
import           Plutus.PAB.Webserver.Types   (ContractActivationArgs (..))
import           Plutus.Trace
import           Plutus.Trace.Emulator         as Emulator
import           Plutus.V1.Ledger.Credential   as Plutus
import           Plutus.V1.Ledger.Crypto       as Plutus
import           Plutus.V1.Ledger.Value        (TokenName (..))

import qualified PlutusTx
import           PlutusTx                      (Data (..))
import           PlutusTx.Prelude
import           PlutusTx.Prelude              hiding (unless)
import           PlutusTx.Prelude              hiding (Semigroup(..), unless)
import           PlutusTx.Prelude              hiding (Semigroup(..), check, unless)
import qualified PlutusTx.Builtins             as Builtins
import           PlutusTx.Builtins             (toBuiltin)
import           PlutusTx.Builtins.Internal    (BuiltinByteString (..))
import           PlutusTx.Code                 (getCovIdx)
import           PlutusTx.Coverage             (CoverageIndex)

import           Prettyprinter                 (Pretty (..), viaShow)

import           Schema                        (ToSchema)

import           Text.Printf                   (printf)
import           Text.Read (readMaybe)

import           Wallet.Emulator.Wallet
import           Wallet.Emulator.Wallet        (knownWallet, mockWalletAddress)
import           Wallet.Emulator.Wallet        (WalletId (..), Wallet (..))
import           Wallet.Types                  (ContractInstanceId (..))

import           Week03.Parameterized
import           Week04.Vesting
import           Week04.Monad
import qualified Week06.Monitor                as Monitor
import           Week06.Token.OffChain
import qualified Week06.Token.OffChain         as Token
import           Week07.EvenOdd
import           Week07.RockPaperScissors
import           Week07.StateMachine

I have also determined (by analyzing all the plutus-pioneer-program-week0x.cabal files) that the following packages are variously included in the various projects:

 build-depends:       aeson
                     , ansi-terminal
                     , base ^>=
                     , req ^>= 3.9.0
                     , bytestring
                     , cardano-api
                     , cardano-crypto-class
                     , cardano-ledger-core
                     , cardano-ledger-shelley
                     , cardano-wallet-core
                     , containers
                     , data-default
                     , freer-extras
                     , freer-simple
                     , html-entities
                     , lens
                     , openapi3
                     , playground-common
                     , plutus-contract
                     , plutus-ledger
                     , plutus-ledger-api
                     , plutus-ledger-constraints
                     , plutus-pab
                     , plutus-tx
                     , plutus-tx-plugin
                     , plutus-use-cases
                     , prettyprinter
                     , QuickCheck
                     , serialise
                     , tasty
                     , tasty-hunit
                     , tasty-quickcheck

                     , plutus-pioneer-program-week06
                     , plutus-pioneer-program-week08

  if !(impl(ghcjs) || os(ghcjs))
    build-depends: plutus-tx-plugin -any

Is there any comprehensive source that lists what modules are in what packages? The haddock does not appear to be structured in this way.

Even better...

  1. Is there a source that explains and demonstrates how to use each of those modules, including each and every function/type/etc. within each module? I find the haddock and related docs are more of a dense inventory than a teaching tool. Of course, maybe this is exactly what pioneers are meant to build (I'm trying)!

  2. Where do all those packages come from? I assume they are hiding in that massive 67GB nix store I downloaded as part of the setup process, but is there any order to it all?

  3. Considering that each module may have dozens of internally defined types/functions/etc., the dizzying array of unfamiliar terms is causing what I shall dub "magic word syndrome". No question here, just a plea for symptom relief.

I have numerous other questions about how all of this is structured/connected but this is enough for one "question". Thank you one and all.

1 Answer 1


Is there any comprehensive source that lists what modules are in what packages?

Not really, but Hackage has all the packages available from Hackage as well as providing their documentation.

Is there a source that explains and demonstrates how to use each of those modules,

No, but Hackage (above) does give some of this.

Where do all those packages come from?


  • I don't think so. I think many (all?) of the plutus packages are not yet on hackage because they are still being developed. Being new to Haskell and Plutus, the boundary between what is hackage and what is plutus is still blurry. But I'll spend some time on hackage working to get at least halfway where I need to be.
    – XiTouch
    Mar 14, 2022 at 8:09
  • 1
    Plutus and Cardano ones are not, but the vast majority of the others in the cabal file fragment you posted are. Mar 14, 2022 at 9:00

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.