First version

Author: paulvictor

.purs-repl

@@ -0,0 +1 @@
+import Prelude

bower.json

@@ -0,0 +1,24 @@
+{
+  "name": "purescript-dplyr",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^4.0.1",
+    "purescript-console": "^4.1.0",
+    "purescript-effect": "^2.0.0",
+    "purescript-transformers": "^4.1.0",
+    "purescript-newtype": "^3.0.0",
+    "purescript-lists": "^5.0.0",
+    "purescript-generics-rep": "^6.0.0",
+    "purescript-filterable": "^3.0.1",
+    "purescript-record": "^1.0.0",
+    "purescript-record-extra": "^1.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^4.0.0"
+  }
+}

src/Data/DataFrame.purs

@@ -0,0 +1,35 @@
+module Data.DataFrame where
+
+import Prelude
+
+import Data.Compactable (class Compactable, separate)
+import Data.Filterable (class Filterable, partitionMap)
+import Data.Generic.Rep (class Generic)
+import Data.List (catMaybes, mapMaybe, partition)
+import Data.List (filter) as List
+import Data.List.Types (List)
+import Data.Newtype (class Newtype, over, unwrap, wrap)
+
+newtype DataFrame a = DataFrame (List a)
+
+derive instance newtypeDF :: Newtype (DataFrame a) _
+
+derive instance genericDF :: Generic (DataFrame a) _
+
+derive instance functorDF :: Functor DataFrame
+
+instance semigroupDF :: Semigroup (DataFrame a) where
+  append (DataFrame l1) (DataFrame l2) = wrap $ append l1 l2
+
+instance monoidDF :: Monoid (DataFrame a) where
+  mempty = wrap mempty
+
+instance compactbleDF :: Compactable DataFrame where
+  compact = over DataFrame catMaybes
+  separate = (\{left, right} -> {left: wrap left, right: wrap right}) <<< separate <<< unwrap
+
+instance filterableDF :: Filterable DataFrame where
+  filter f = over DataFrame (List.filter f)
+  filterMap f = over DataFrame (mapMaybe f)
+  partition f = (\{yes, no} -> {yes: wrap yes, no: wrap no}) <<< partition f <<< unwrap
+  partitionMap f = (\{left, right} -> {left: wrap left, right: wrap right}) <<< partitionMap f <<< unwrap

src/Data/Query.purs

@@ -0,0 +1,126 @@
+module Data.Query where
+
+import Prelude
+
+import Control.Monad.Reader.Class (ask)
+import Control.Monad.Reader.Trans (ReaderT)
+import Data.DataFrame (DataFrame(..))
+import Data.Filterable (filter) as Filterable
+import Data.Function (on)
+import Data.List (sortBy)
+import Data.List.Lazy (List, uncons, (:))
+import Data.List.Lazy (filter) as L
+import Data.Maybe (maybe)
+import Data.Newtype (over)
+import Data.Ordering (invert)
+import Data.Symbol (class IsSymbol, SProxy(..))
+import Prim.Row (class Cons, class Lacks)
+import Prim.RowList (class RowToList, Cons, Nil, kind RowList)
+import Record (get, insert)
+import Record (insert, rename) as R
+import Type.Row (class ListToRow, RLProxy(..), RProxy)
+
+type Query m a b = ReaderT (DataFrame a) m (DataFrame b)
+
+filter :: ∀ m a. Monad m => (a -> Boolean) -> Query m a a
+filter f = (Filterable.filter f) <$> ask
+
+arrange
+  :: ∀ m sym a rec without
+  . Ord a
+  => Monad m
+  => IsSymbol sym
+  => Lacks sym without
+  => Cons sym a without rec
+  => SProxy sym
+  -> Boolean
+  -> Query m ({|rec}) ({|rec})
+arrange proxy asc = (over DataFrame $ sortBy (comp `on` (get proxy))) <$> ask
+  where
+    comp :: a -> a -> Ordering
+    comp a = if asc then compare a else invert <<< compare a
+
+pull
+  :: ∀ m sym a rec without' without
+  . Monad m
+  => IsSymbol sym
+  => Lacks sym without
+  => Lacks sym without'
+  => Cons sym a without rec
+  => SProxy sym
+  -> Query m {|rec} a
+pull proxy = (over DataFrame $ map (( get proxy))) <$> ask
+
+class RowSubset (row :: # Type) (xs :: RowList) (subrow :: # Type) | row xs -> subrow where
+  subsetImpl :: RLProxy xs -> {|row} -> {|subrow}
+
+instance nilRowSubset :: RowSubset row Nil () where subsetImpl _ _ = {}
+
+instance consRowSubset
+  ::
+  ( IsSymbol sym
+  , Cons sym a subrowWithoutSym subrowWithSym
+  , Cons sym a srcWithoutSym src
+  , Lacks sym subrowWithoutSym
+  , RowSubset src rl subrowWithoutSym
+  ) => RowSubset src (Cons sym a rl) subrowWithSym where
+  subsetImpl _ src = insert (SProxy :: SProxy sym) (get (SProxy :: SProxy sym) src) (subsetImpl (RLProxy :: RLProxy rl) src)
+
+subsetRow
+  :: ∀ rl subR src
+  . ListToRow rl subR
+  => RowToList subR rl
+  => RowSubset src rl subR
+  => {|src}
+  -> RProxy subR
+  -> {|subR}
+subsetRow src _ = subsetImpl (RLProxy :: RLProxy rl) src
+
+select
+  :: ∀ m rec rl subR
+  . Monad m
+  => RowSubset rec rl subR
+  => RowToList subR rl
+  => ListToRow rl subR
+  => RProxy subR
+  -> Query m {|rec} {|subR}
+select proxy = (map (flip subsetRow proxy)) <$> ask
+
+rename
+  :: ∀ m inter input output sym sym' a
+  . Monad m
+  => IsSymbol sym
+  => IsSymbol sym'
+  => Cons sym a inter input
+  => Lacks sym inter
+  => Cons sym' a inter output
+  => Lacks sym' inter
+  => SProxy sym
+  -> SProxy sym'
+  -> Query m {|input} {|output}
+rename proxy proxy' = (map (R.rename proxy proxy')) <$> ask
+
+mutate
+  :: ∀ m input output sym a
+  . Monad m
+  => IsSymbol sym
+  => Lacks sym input
+  => Cons sym a input output
+  => SProxy sym
+  -> ({|input} -> a)
+  -> Query m {|input} {|output}
+mutate proxy f = (map (\r -> R.insert proxy (f r) r)) <$> ask
+
+transmute
+  :: ∀ m input sym a out
+  . Monad m
+  => IsSymbol sym
+  => Lacks sym ()
+  => Cons sym a () out
+  => SProxy sym
+  -> ({|input} -> a)
+  -> Query m {|input} {|out}
+transmute proxy f = (map \r -> R.insert proxy (f r) {}) <$> ask
+
+sort :: ∀ a. Ord a => List a -> List a
+sort xs = maybe mempty (\{ head, tail } -> (sort $ L.filter (_ <= head) tail) <> (head : (sort $ L.filter (_ > head) tail))) $ uncons xs

src/Main.purs

@@ -0,0 +1,9 @@
+module Main where
+
+import Prelude
+import Effect (Effect)
+import Effect.Console (log)
+
+main :: Effect Unit
+main = do
+  log "Hello sailor!"

test/Main.purs

@@ -0,0 +1,9 @@
+module Test.Main where
+
+import Prelude
+import Effect (Effect)
+import Effect.Console (log)
+
+main :: Effect Unit
+main = do
+  log "You should add some tests."