chore: typos on getting started guide

Author: euonymos

docs/getting-started.md

@@ -5,7 +5,7 @@
 An instance of `CEMScript` revolves primarily around the following two type classes.
 
 Here, `script` is an uninhabited type that is used to
-tie together the different types associated with an instance of CEMScript.
+tie together the different types associated with an instance of CEMScript.on
 
 `CEMScriptTypes` defines those types:
 
@@ -37,8 +37,8 @@ class
   -- | The crux part - a map that defines constraints for each transition via DSL.
   transitionSpec :: CEMScriptSpec False script
 
-  -- | Optional Plutus script to calculate things, whic can be used in the cases
-  -- when CEM constrainsts and/or inlining Plutarch functions are not expresisble
+  -- | Optional Plutus script to calculate things, which can be used in the cases
+  -- when CEM constraints and/or inlining Plutarch functions are not expressible
   -- enough.
   transitionComp ::
     Maybe
@@ -61,11 +61,11 @@ type CEMScriptSpec resolved script =
 
 ### Spine
 
-Spine of an ADT is a sum type that is just a list of it’s constructors.
+The spine of an ADT is a sum type that is just a list of its constructors.
 
-`HasSpine` type class maps from an ADT to it’s Spine type and:
+`HasSpine` type class maps from an ADT to its Spine type and:
 
-- associates the type to it’s Spine type through a type family
+- associates the type to its Spine type through a type family
 - defines a function that translates an instance of the type to an instance of the spine type
 
 ```haskell
@@ -75,12 +75,12 @@ class HasSpine sop where
   getSpine :: sop -> Spine sop
 ```
 
-We provide a function `deriveSpine` to automatically derive `HasSpine` using template haskell.
+Using the Template Haskell, we provide a function `deriveSpine` to automatically derive `HasSpine`.
 
 ### DSL
 
 When writing `CEMScript` transitions, we start by describing constraints
-at a high level using a DSL that consistes of the following types:
+at a high level using a DSL that consists of the following types:
 
 #### TxConstraint
 
@@ -92,8 +92,10 @@ data TxConstraint (resolved :: Bool) script where
 `TxConstraint` is a GADT (Generalized Algebraic Data Type) parameterized by two things:
 
 1. **`resolved`**: A Boolean type flag (usually `True` or `False`) indicating whether the constraint is in a "resolved" form.
-In on-chain code, `resolved` will be `False`, representing the actual computation that’s going to take place. In off-chain code, `resolved` will be `True`, which is used to derive a valid transaction from a list of `TxConstraint`s. See the Off-chain machinery section for more details on how this works.
-2. **`script`**: A phantom type parameter indicating which CEMScript (state machine) the constraints belong to.
+In on-chain code, `resolved` will be `False`, representing the actual computation that’s going to take place.
+In off-chain code, `resolved` will be `True`, which is used to derive a valid transaction from a list of `TxConstraint`s.
+See the Off-chain machinery section for more details on how this works.
+3. **`script`**: A phantom type parameter indicating which CEMScript (state machine) the constraints belong to.
 
 See the reference section for a full reference of `TxConstraint`.
 
@@ -102,9 +104,10 @@ See the reference section for a full reference of `TxConstraint`.
 `ConstraintDSL script value` is a GADT that represents a symbolic expression in the DSL.
 
 - `script` is a phantom type parameter, just like in `TxConstraint`.
-- `value` is the type of the what this expression will resolve to during runtime.
+- `value` is the type of what this expression will resolve during runtime.
 
-`ConstraintDSL` allows us to reference parts of the state machine's parameters, the current state, the transition arguments, and so forth.
+`ConstraintDSL` allows us to reference parts of the state machine's parameters, 
+the current state, the transition arguments, and so forth.
 
 It also lets us perform checks (like equality) and apply transformations (like lifting a Plutarch function).
 
@@ -122,7 +125,7 @@ type family DSLPattern (resolved :: Bool) script value where
   DSLPattern True  _      value = Void
 ```
 
-These are both type level wrappers over `ConstraintDSL`.
+These are both type-level wrappers over `ConstraintDSL`.
 
 The type parameter `resolved` will be False for on-chain code, while it will be True for off-chain code.
 
@@ -179,7 +182,7 @@ data ResolvedTx = MkResolvedTx
 
 ```
 
-`resolveTx` is the primary entrypoint for off-chain code.
+`resolveTx` is the primary entry point for off-chain code.
 It accepts a  `TxSpec`, which consists of a list of actions and a signer,
 and produces a `ResolvedTx`, which is all the information needed to construct
 a transaction that’s ready to be submitted to the chain.
@@ -188,10 +191,10 @@ Here’s a rough outline of how it works:
 
 - For each `Transition` in the list of actions
     - Find the corresponding transition in the `transitionSpec`
-    - If the transition spec contains a `TxFan In SameScript` , check the current on-chain state is the same a required by the constraint.
-    - Convert the `[TxConstraint (resolved :: False)]` of the `Transition` to `[TxConstraint (resolved :: True)]` by invoking `compileConstraint` .
+    - If the transition spec contains a `TxFan In SameScript`, check the current on-chain state is the same as required by the constraint.
+    - Convert the `[TxConstraint (resolved :: False)]` of the `Transition` to `[TxConstraint (resolved :: True)]` by invoking `compileConstraint`.
 
-        This evaluates all the `DSLValue _ value`  expressions and resolve it to a value of type `value`.
+        This evaluates all the `DSLValue _ value`  expressions and resolves it to a value of type `value`.
 
         The following variants of `TxConstraint`
 
@@ -320,12 +323,12 @@ data TxConstraint (resolved :: Bool) script
     Ensure
 
     - The sum of input utxos belonging to `user` is greater than `inValue`
-    - The sume of output utxos belonging to `user` is greater than `outValue`
+    - The sum of output utxos belonging to `user` is greater than `outValue`
 - `MainSignerNoValue address` Ensure that the given address is part of the transaction signatories.
 - `Error message` Output `message` using `ptrace` as an error message.
 - `If`
     - Evaluate the condition and resolve to the `TxConstraint` in the “then” branch or the “else” branch.
-- `MatchBySpine pattern map` Evaluate pattern and execute the corresponding action from `map`
+- `MatchBySpine pattern map` Evaluate the pattern and execute the corresponding action from `map`
     - `map` Map from `Spine` to `TxConstraint`
 
 In addition to the above, CEMScript provides the following helper functions to create `TxConstraint`s
@@ -343,9 +346,9 @@ byFlagError flag message = If flag (Error message) Noop
 
 ```
 
-- `cNot` invert a boolean
-- `offchainOnly` execute only on chain. Resolve to `Noop` off chain.
-- `byFlagError` evaluate to `Error message` if `flag` evaluates to true.
+- `cNot` inverts a boolean
+- `offchainOnly` executes only on chain. Resolve to `Noop` off chain.
+- `byFlagError` evaluates to `Error message` if `flag` evaluates to true.
 
 ### ConstraintDSL
 
@@ -371,7 +374,7 @@ data ConstraintDSL script value where
   -- Primitives
 
   -- A wildcard pattern that matches any value.
-  -- Used in pattern matching contexts where the actual value is irrelevant.
+  -- Used in pattern-matching contexts where the actual value is irrelevant.
   Anything :: ConstraintDSL script x
   -- Compare two DSL values
   Eq :: (..) => ConstraintDSL script x -> ConstraintDSL script x -> ConstraintDSL script Bool
@@ -415,7 +418,7 @@ cMinLovelace = cMkAdaOnlyValue $ Pure 3_000_000
 (@==) = Eq
 ```
 
-The following are lifted versions of plutrach operators
+The following are lifted versions of Plutarch operators
 
 ```haskell
 (@<=) -- #<=
@@ -438,8 +441,8 @@ The following are lifted versions of plutrach operators
 
 ### How to define a script
 
-- Define an empty type for your script: `data MyScript` , where MyScript can be any name.
-- Define a `CEMScript` instance for it by providing `Params`, `State`, `Transition`, `transitionSpec` and optionally `transitionComp`.
+- Define an empty type for your script: `data MyScript`, where MyScript can be any name.
+- Define a `CEMScript` instance for it by providing `Params`, `State`, `Transition`, `transitionSpec`, and optionally `transitionComp`.
 - Do Template Haskell derivations (`deriveCEMAssociatedTypes`) to generate data and spine instances for pattern matching.
 - Invoke the `compileCEM` function (e.g., `$(compileCEM True ''MyScript)`) to process the DSL specification, compile optional `transitionComp` code, and produce a `CEMScriptCompiled` instance.
     - This generates an instance of `CEMScriptCompiled` for your script type.
@@ -449,13 +452,15 @@ The following are lifted versions of plutrach operators
 
 #### Setup: The Types
 
-First we define a type to denote our script. It’s an uninhabited type, it can’t be constructed. It’s only used as a tag for connecting different type classes together.
+First, we define a type to denote our script. It’s an uninhabited type, it can’t be constructed. 
+It’s only used as a tag for connecting all instances of type classes together.
 
 ```haskell
 data SimpleAuction
 ```
 
-We define a type for the read-only state of our script. This state can’t be modified once created. This becomes the `Params` associated type of the `CEMScript` typeclass.
+We define a type for the read-only state of our script. This state can’t be modified once created. 
+This becomes the `Params` associated type of the `CEMScript` type class.
 
 ```haskell
 data SimpleAuctionParams = MkAuctionParams
@@ -465,7 +470,7 @@ data SimpleAuctionParams = MkAuctionParams
   deriving stock (Prelude.Eq, Prelude.Show)
 ```
 
-We define a type for the evolving state of our script. This becomes the `State` associated type of the `CEMScript` typeclass.
+We define a type for the evolving state of our script. This becomes the `State` associated type of the `CEMScript` type class.
 
 ```haskell
 data Bid = MkBid
@@ -487,7 +492,7 @@ data SimpleAuctionState
   deriving stock (Prelude.Eq, Prelude.Show)
 ```
 
-Lastly, we define a type for the state transitions of our script. This becomes the `Transition` associated type of the `CEMScript` typeclass.
+Lastly, we define a type for the state transitions of our script. This becomes the `Transition` associated type of the `CEMScript` type class.
 
 ```haskell
 data SimpleAuctionTransition
@@ -501,7 +506,10 @@ data SimpleAuctionTransition
   deriving stock (Prelude.Eq, Prelude.Show)
 ```
 
-We can now define an instance of the `CEMScriptTypes` for `SimpleAuction` . `CEMScriptTypes` is a super class of `CEMScript`, which just includes the associated types. By defining the associated types separately, we can use the `deriveCEMAssociatedTypes` template haskell function to generate some boilerplate.
+We can now define an instance of the `CEMScriptTypes` for `SimpleAuction`.
+`CEMScriptTypes` is a superclass of `CEMScript`, which just includes the associated types. 
+By defining the associated types separately, we can use the `deriveCEMAssociatedTypes` 
+Template Haskell function to generate some boilerplate.
 
 ```haskell
 instance CEMScriptTypes SimpleAuction where
@@ -512,9 +520,11 @@ instance CEMScriptTypes SimpleAuction where
 $(deriveCEMAssociatedTypes False ''SimpleAuction)
 ```
 
-`deriveCEMAssociatedTypes` just executes `derivePlutusSpine` for all three of the associated types. But it can only do that if all the members of a type have a `HasPlutusSpine` implementation. This is why we need to do `derivePlutusSpine` for the `Bid` type ourselves.
+`deriveCEMAssociatedTypes` just executes `derivePlutusSpine` for all three of the associated types. 
+But it can only do that if all the members of a type have a `HasPlutusSpine` implementation. 
+This is why we need to do `derivePlutusSpine` for the `Bid` type ourselves.
 
-The boolean argument to `deriveCEMAssociatedTypes` is unused for now, and it is recommended to use a value of `False` .
+The boolean argument to `deriveCEMAssociatedTypes` is unused for now, and it is recommended to use a value of `False`.
 
 #### Implementation
 
@@ -524,13 +534,14 @@ To implement the logic of our script, we define an instance of `CEMScript` for o
 instance CEMScript SimpleAuction where
 ```
 
-We provide a value for `compilationConfig` , which at the moment contains only a prefix for error codes to tell errors from different programs apart.
+We provide a value for `compilationConfig`, which at the moment contains 
+only a prefix for error codes to tell errors from different programs apart.
 
 ```haskell
   compilationConfig = MkCompilationConfig "AUC"
 ```
 
-Next comes the meat of the script: `transitionSpec` . This is where we define state transitions
+Next comes the meat of the script: `transitionSpec`. This is where we define state transitions
 
 We create a Map of `Spine (Transition script)` → `[TxConstraint False script]`
 
@@ -556,7 +567,7 @@ auctionValue = cMinLovelace @<> ctxParams.lot
 
 We make extensive use of `OverloadedRecordDot` and custom `HasField` instances to make accessing the fields of the params and state values ergonomic.
 
-Let’s examine each of the entries of the map in detail.
+Let’s examine each of the entries in the map in detail.
 
 1. Create