chore: Slight updates to documentation.

Author: mchav

docs/coming_from_other_implementations.md

@@ -59,7 +59,7 @@ ghci> D.fromList [Just (1 :: Double), Just 3, Just 5, Nothing, Just 6, Just 8]
 [Just 1.0, Just 3.0, Just 5.0, Nothing, Just 6.0, Just 8.0]
 ```
 
-This approach is superior because:
+This approach is better because:
 - The type system forces you to handle missing values explicitly
 - You can't accidentally treat `Nothing` as a number
 - Pattern matching ensures you consider all cases
@@ -598,10 +598,10 @@ Example:
 
 ```haskell
 -- Using lift for a unary function
-D.derive "doubled" (F.lift (*2) (F.col @Double "weight"))
+D.derive "doubled" (F.lift (*2) weight)
 
 -- Using lift2 for a binary function
-D.derive "weight_per_height" (F.lift2 (/) (F.col @Double "weight") (F.col @Double "height"))
+D.derive "weight_per_height" (F.lift2 (/) weight height)
 ```
 
 #### Column Expansion
@@ -620,8 +620,10 @@ We don't provide built-in column expansion, so you write multiple explicit opera
 
 ```haskell
 df_csv
-    |> D.derive "weight-5%" ((F.col @Double "weight") * (F.lit 0.95))
-    |> D.derive "height-5%" ((F.col @Double "height") * (F.lit 0.95))
+    |> D.deriveMany
+          [ "weight-5%" .=  weight * 0.95
+          , "height-5%" .= height * 0.95
+          ]
     |> D.select ["name", "weight-5%", "height-5%"]
 ```
 
@@ -749,7 +751,6 @@ let decade d = let (y, _, _) = toGregorian d
 
 df_csv
     |> D.derive "decade" (F.lift decade (F.col @Day "birthdate"))
-    |> D.select ["decade"]
     |> D.groupBy ["decade"]
     |> D.aggregate [F.count (F.col @Day "decade") `F.as` "Count"]
 ```

docs/intro_to_probability_and_data.md

@@ -48,7 +48,7 @@ ghci>  df
 You can see the dimensions of this data frame by typing:
 
 ```haskell
-ghci> D.dimension arbuthnot
+ghci> D.dimensions arbuthnot
 
 ```
 

docs/quick_start.md

@@ -26,6 +26,7 @@
 
 ### Example usage
 
+#### GHCi/Jupyter notebooks
 Looking through the structure of the columns.
 
 ```haskell    
@@ -114,3 +115,34 @@ Key features in example:
 * Create type-safe references to columns in a dataframe using :exposeColumns
 * Type-safe column transformations for faster and safer exploration.
 * Fluid, chaining API that makes code easy to reason about.
+
+#### Standalone scripts
+
+We provide a small, monadic DSL for scripts where you want relatively more type safety.
+
+```haskell
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module Main where
+
+import qualified DataFrame as D
+import qualified DataFrame.Functions as F
+
+import DataFrame.Monad
+
+import Data.Text (Text)
+import DataFrame.Functions ((.&&), (.>=))
+
+$(F.declareColumnsFromCsvFile "./data/housing.csv")
+
+main :: IO ()
+main = do
+    df <- D.readCsv "./data/housing.csv"
+    print $ runFrameM df $ do
+        -- 1) Type safe reference to `median_house_value` and `median_income`
+        -- 2) creates a type safe reference to the newly created column.
+        is_expensive <- deriveM "is_expensive" (median_house_value .>= 500000)
+        luxury <- deriveM "luxury" (is_expensive .&& median_income .>= 8)
+        filterWhereM luxury
+```

src/DataFrame/Monad.hs

@@ -4,6 +4,7 @@
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}
+{-# LANGUAGE InstanceSigs #-}
 
 module DataFrame.Monad where
 
@@ -20,18 +21,21 @@ import qualified Data.Text as T
 newtype FrameM a = FrameM {runFrameM_ :: DataFrame -> (DataFrame, a)}
 
 instance Functor FrameM where
+    fmap :: (a -> b) -> FrameM a -> FrameM b
     fmap f (FrameM g) = FrameM $ \df ->
         let (df', x) = g df
          in (df', f x)
 
 instance Applicative FrameM where
     pure x = FrameM (,x)
+    (<*>) :: FrameM (a -> b) -> FrameM a -> FrameM b
     FrameM ff <*> FrameM fx = FrameM $ \df ->
         let (df1, f) = ff df
             (df2, x) = fx df1
          in (df2, f x)
 
 instance Monad FrameM where
+    (>>=) :: FrameM a -> (a -> FrameM b) -> FrameM b
     FrameM g >>= f = FrameM $ \df ->
         let (df1, x) = g df
             FrameM h = f x
@@ -40,7 +44,7 @@ instance Monad FrameM where
 deriveM :: (Columnable a) => T.Text -> Expr a -> FrameM (Expr a)
 deriveM name expr = FrameM $ \df ->
     let df' = D.derive name expr df
-     in (df', expr) -- or (df', F.col @a name)
+     in (df', expr)
 
 filterWhereM :: Expr Bool -> FrameM ()
 filterWhereM p = FrameM $ \df ->