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 ^>=4.14.1.0
, 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...
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)!
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?
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.
