A better show instance + more helpers

Author: paulvictor

src/Data/DataFrame.purs

@@ -2,13 +2,14 @@ module Data.DataFrame where
 
 import Prelude
 
+import Control.Apply (lift2)
 import Data.Compactable (class Compactable, separate)
 import Data.Filterable (class Filterable, partitionMap)
 import Data.Foldable (intercalate, maximum, surround)
 import Data.Function (on)
 import Data.Generic.Rep (class Generic)
 import Data.List (catMaybes, head, mapMaybe, partition, sortBy, take, transpose)
-import Data.List (filter) as List
+import Data.List (filter, length) as List
 import Data.List.Types (List)
 import Data.Map (Map)
 import Data.Map (toUnfoldable) as Map
@@ -18,7 +19,6 @@ import Data.Newtype (class Newtype, over, unwrap, wrap)
 import Data.String (length)
 import Data.String.NonEmpty (NonEmptyString)
 import Data.Tuple (fst, snd)
-import Data.Tuple.Nested (type (/\))
 
 newtype DataFrame a = DataFrame (List a)
 
@@ -47,21 +47,28 @@ instance filterableDF :: Filterable DataFrame where
 instance showUntypedDataFrame :: Show a => Show (DataFrame (Map NonEmptyString a)) where
   show =
     unwrap >>>
-    take 10 >>>
-    map (Map.toUnfoldable >>> sortBy (compare `on` fst)) >>>
-    transpose >>>
-    map drawColumn >>>
-    transpose >>>
-    map (surround " | ") >>> ((flip intercalate) <*> (head >>> maybe 0 length >>> power "-" >>> (_ <> "\n")))
+    (lift2 (<>) (take 10 >>> showSummary) showRemainingCount)
     where
-    drawColumn :: List (NonEmptyString /\ a) -> List String
+    showSummary =
+      map (Map.toUnfoldable >>> sortBy (compare `on` fst))
+      >>> transpose
+      >>> map drawColumn
+      >>> transpose
+      >>> map (surround " | ")
+      >>> (flip intercalate <*> head >>> maybe 0 length >>> power "-" >>> (_ <> "\n"))
     drawColumn xs =
       map
         (snd >>> padTo (max (maxLengthOfValues xs) (maybe 0 (fst >>> show >>> length) (head xs))))
         xs
-    maxLengthOfValues :: List (NonEmptyString /\ a) -> Int
-    maxLengthOfValues = map (snd >>> show >>> length) >>> maximum >>> fromMaybe 0
+    maxLengthOfValues =
+      map (snd >>> show >>> length)
+      >>> maximum
+      >>> fromMaybe 0
     padTo :: Int -> a -> String
     padTo i a =
       let pad = power " " $ (i - length (show a)) / 2
       in pad <> show a <> pad
+    showRemainingCount =
+      List.length >>>
+      (_ - 10) >>>
+      ((\l -> if _ then "\n... and " <> show l <> " more" else mempty) <*> (_ > 0))

src/Data/Query.purs

@@ -7,10 +7,11 @@ import Control.Monad.Reader.Trans (ReaderT)
 import Data.DataFrame (DataFrame(..))
 import Data.Filterable (filter) as Filterable
 import Data.Foldable (foldr)
-import Data.List (List, (:))
+import Data.Function (on)
+import Data.List (List, length, sortBy, takeEnd, (:))
 import Data.Map (alter, empty, toUnfoldable) as Map
 import Data.Maybe (Maybe(..), maybe)
-import Data.Newtype (over)
+import Data.Newtype (over, unwrap)
 import Data.Tuple (snd)
 import Data.Tuple.Nested (type (/\))
 
@@ -46,3 +47,25 @@ ungroup
   . Monad m
   => Query m (b /\ (List a)) a
 ungroup = asks (over DataFrame (map snd >>> join))
+
+_do
+  :: ∀ m a b
+  . Monad m
+  => (List a -> b)
+  -> ReaderT (DataFrame a) m b
+_do f = asks (f <<< unwrap)
+
+count
+  :: ∀ m a
+  . Monad m
+  => ReaderT (DataFrame a) m Int
+count = _do length
+
+top_n_by
+  :: ∀ m a b
+  . Monad m
+  => Ord b
+  => Int
+  -> (a -> b)
+  -> Query m a a
+top_n_by n f = asks (over DataFrame (sortBy (compare `on` f)  >>> takeEnd n))

src/Data/Query/Record.purs

@@ -2,6 +2,7 @@ module Data.Query.Record where
 
 import Prelude
 
+import Control.Apply (lift2)
 import Control.Monad.Reader.Class (asks)
 import Data.DataFrame (DataFrame(..))
 import Data.Function (on)
@@ -101,7 +102,7 @@ mutate
   => SProxy sym
   -> ({|input} -> a)
   -> Query m {|input} {|output}
-mutate proxy f = asks (map (\r -> R.insert proxy (f r) r))
+mutate proxy f = asks (map (lift2 (R.insert proxy) f identity))
 
 transmute
   :: ∀ m input sym a out
@@ -112,4 +113,4 @@ transmute
   => SProxy sym
   -> ({|input} -> a)
   -> Query m {|input} {|out}
-transmute proxy f = asks (map \r -> R.insert proxy (f r) {})
+transmute proxy f = asks (map (f >>> flip (R.insert proxy) {}))

src/Data/Query/Untyped.purs

@@ -2,21 +2,21 @@ module Data.Query.Untyped where
 
 import Prelude
 
+import Control.Apply (lift2)
 import Control.Monad.Reader.Trans (asks)
 import Data.Bifunctor (lmap)
 import Data.DataFrame (DataFrame(..))
 import Data.Foldable (elem)
 import Data.Function (on)
 import Data.List (sortBy)
 import Data.List.NonEmpty (NonEmptyList)
-import Data.Map (Map)
 import Data.Map (filterKeys, insert, lookup, pop) as Map
 import Data.Maybe (Maybe, fromMaybe, maybe)
 import Data.Newtype (over)
 import Data.Ordering (invert)
 import Data.Query (Query)
 import Data.String (Pattern(..))
-import Data.String.NonEmpty (NonEmptyString, stripPrefix)
+import Data.String.NonEmpty (stripPrefix)
 import Data.Tuple (uncurry)
 import Types (Column, Row)
 
@@ -61,7 +61,7 @@ mutate
   => Column
   -> (Row a -> a)
   -> Query m (Row a) (Row a)
-mutate column f = asks (map (\r -> Map.insert column (f r) r))
+mutate column f = asks (map (lift2 (Map.insert column) f identity))
 
 transmute
   :: ∀ m a