packages feed

rethinkdb (empty) → 0.1.0.0

raw patch · 52 files changed

+5166/−0 lines, 52 filesdep +aesondep +attoparsecdep +basesetup-changed

Dependencies added: aeson, attoparsec, base, bytestring, containers, data-default, ghc-prim, mtl, network, protocol-buffers, text, unordered-containers

Files

+ Database/RethinkDB.hs view
@@ -0,0 +1,100 @@++-- | RethinkDB client library for Haskell+-- +-- Modelled upon the official Javascript and Python API: <http://www.rethinkdb.com/api/>+-- +-- /How to use/+--  +-- >>> import Database.RethinkDB+-- >>> import qualified Database.RethinkDB.Functions as R++module Database.RethinkDB (+  +  -- * Accessing RethinkDB+  +  RethinkDBHandle,+  openConnection,+  closeConnection, +  use,+  run, runMaybe, runEither, runRaw, runJSON, runBatch,+  next, collect, resultsError,+  +  -- * Manipulating databases+  +  Database(..),+  db, dbCreate, dbDrop, dbList, +  +  -- * Manipulating Tables+  +  Table(..), tablePrimaryAttr, TableCreateOptions(..),+  table, tableCreate, tableDrop, tableList,+  +  -- * Writing data+  +  Document(..), +  insert, insertMany, upsert, upsertMany,+  update, replace, delete,+  +  -- * Selecting data+  +  get, filter', between,+  +  -- * Joins+  +  innerJoin, outerJoin, eqJoin, zip',+  +  -- * Transformations+  +  map', concatMap', orderBy, skip, limit,+  slice, nth, pluck, without, union',+  +  -- * Aggregation+  +  reduce, count, distinct, groupedMapReduce, groupBy',+  +  -- * Reductions+  +  count', sum', avg,+  +  -- * Document manipulation+  +  pick, unpick, merge, append, (!), (!?),+  +  -- * Operators+  +  concat,+  add, sub, mul, div', mod, and', or',+  eq, ne, gt, ge, lt, le, not',+  +  -- * Control structures+  +  bind, let', var, if', forEach, error', js, jsfun,+  +  -- * Sequence conversion+  +  streamToArray, arrayToStream, asArray,++  -- * Short constructors+  +  Obj, Attribute(..), obj, str, nil,+  +  -- * Types and type classes+  +  Query, ToQuery(..),+  ValueTypeKind(..), ExprTypeKind(..),+  ExprIsView, ExprValueType, Expr(..), ToExpr(..), ToValue(..),+  HasValueType, HaveValueType,+  NumberExpr, BoolExpr, ObjectExpr, ArrayExpr, StringExpr, ValueExpr,+  NumberStream, BoolStream, ObjectStream, ArrayStream, StringStream, Selection,+  CanCompare,+  Order(..), ToOrder(..),+  Sequence(..),+  Mapping(..), ToMapping(..),+  Results+  ) where++import Prelude ()++import Database.RethinkDB.Types+import Database.RethinkDB.Driver+import Database.RethinkDB.Functions
+ Database/RethinkDB/Driver.hs view
@@ -0,0 +1,1224 @@+{-# LANGUAGE OverloadedStrings, KindSignatures, DataKinds, MultiParamTypeClasses, +             TypeFamilies, ExistentialQuantification, FlexibleInstances, +             ConstraintKinds, FlexibleContexts, UndecidableInstances, +             PolyKinds, FunctionalDependencies, GADTs, ScopedTypeVariables, +             RankNTypes, RecordWildCards #-}++-- | The core of the haskell client library for RethinkDB++module Database.RethinkDB.Driver where++import {-# SOURCE #-} Database.RethinkDB.Functions+import Database.RethinkDB.Types++import Control.Arrow+import Data.Aeson.Types (parseMaybe)+import Data.String+import Data.Typeable+import Data.Data+import GHC.Prim++import qualified Database.RethinkDB.Internal.Types as QL+import qualified Database.RethinkDB.Internal.Query_Language.Response as QLResponse+import qualified Database.RethinkDB.Internal.Query_Language.Query as QLQuery+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as QLVarTermTuple+import qualified Database.RethinkDB.Internal.Query_Language.Predicate as QLPredicate+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as QLBuiltin+import qualified Database.RethinkDB.Internal.Query_Language.ReadQuery as QLReadQuery+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as QLWriteQuery+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as QLMapping+import qualified Database.RethinkDB.Internal.Query_Language.Term as QL (type')+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable as QLCreateTable++import Text.ProtocolBuffers.Basic hiding (Default)+import Text.ProtocolBuffers.WireMessage++import System.IO (Handle, hClose)+import Network++import Data.List+import Control.Monad.State as S+import qualified Data.HashMap.Strict as HM+import Data.Default+import qualified Data.Attoparsec.Lazy as Attoparsec+import Data.Foldable (toList)+import qualified Data.Text as T+import Data.Aeson+import qualified Data.Aeson.Parser (value)+import qualified Data.Sequence as Seq+import Data.Monoid+import Data.Maybe+import Data.ByteString.Lazy (pack, unpack, hPut, hGet)+import qualified Data.ByteString.Lazy as B+import Data.IORef+import Data.Bits++-- * Network++-- | A connection to the database server+data RethinkDBHandle = RethinkDBHandle {+  rdbHandle :: Handle, +  rdbToken :: IORef Int64, -- ^ The next token to use+  rdbDatabase :: Database  -- ^ When no database is specified, this one will be used+  }++-- | Create a new connection to the database server+-- +-- /Example:/ connect using the default port (28015) and specifying the+-- default database for all queries.+-- +-- >>> h <- openConnection "localhost" Nothing (Just "test")++openConnection :: HostName -> Maybe PortID -> Maybe String -> IO RethinkDBHandle+openConnection host port mdb = do+  h <- connectTo host (fromMaybe (PortNumber 28015) port)+  hPut h initialMessage+  r <- newIORef 1+  -- db' <- maybe (fmap head $ run (RethinkDBHandle h r (Database "")) $ dbList) (return . Database) mdb+  let db' = Database $ fromMaybe "" mdb+  return (RethinkDBHandle h r db')+  where initialMessage = packUInt 0xaf61ba35++-- | Set the default connection+-- +-- The new handle is an alias for the old one. Calling closeConnection on either one+-- will close both.+-- +-- >>> let h' = h `use` (db "players")++use :: RethinkDBHandle -> Database -> RethinkDBHandle+use h db' = h { rdbDatabase = db' }++-- | Close an open connection+-- +-- >>> closeConnection h++closeConnection :: RethinkDBHandle -> IO ()+closeConnection (RethinkDBHandle h _ _) = hClose h++-- | Receive a fixed amoutn of data+recvAll :: RethinkDBHandle -> Int -> IO ByteString+recvAll (RethinkDBHandle h _ _) n = hGet h n++-- | Send a bytestring+sendAll :: RethinkDBHandle -> ByteString -> IO ()+sendAll (RethinkDBHandle h _ _) s = hPut h s++-- | Get a request token and increment the token counter+getNewToken :: RethinkDBHandle -> IO Int64+getNewToken (RethinkDBHandle _ r _) = atomicModifyIORef r $ \t -> (t + 1, t)++data ErrorCode = ErrorBrokenClient+               | ErrorBadQuery+               | ErrorRuntime+               | ErrorNetwork++instance Show ErrorCode where+  show ErrorBrokenClient = "broken client error"+  show ErrorBadQuery = "malformed query error"+  show ErrorRuntime = "runtime error"+  show ErrorNetwork = "error talking to server"++data SuccessCode = SuccessEmpty+                 | SuccessJson+                 | SuccessPartial+                 | SuccessStream+                 deriving Show++-- | The raw response to a query+data Response = ErrorResponse {+  errorCode :: ErrorCode,+  errorMessage :: String,+  errorBacktrace :: [String]+  } | SuccessResponse {+  successCode :: SuccessCode,+  successString :: [B.ByteString]+  }++instance Show Response where+  show ErrorResponse {..} = show errorCode ++ ": " +++                            show errorMessage ++ " (" +++                            showBacktrace errorBacktrace ++ ")"+  show SuccessResponse {..} = show successCode ++ ": " ++ show successString++convertResponse :: Either String QL.Response -> Response+convertResponse (Left s) = ErrorResponse ErrorNetwork s []+convertResponse (Right QL.Response {..}) = case status_code of+  QL.SUCCESS_EMPTY   -> SuccessResponse SuccessEmpty   r+  QL.SUCCESS_JSON    -> SuccessResponse SuccessJson    r+  QL.SUCCESS_PARTIAL -> SuccessResponse SuccessPartial r+  QL.SUCCESS_STREAM  -> SuccessResponse SuccessStream  r+  QL.BROKEN_CLIENT   -> ErrorResponse ErrorBrokenClient e bt+  QL.BAD_QUERY       -> ErrorResponse ErrorBadQuery     e bt+  QL.RUNTIME_ERROR   -> ErrorResponse ErrorRuntime      e bt+  where bt = fromMaybe [] $ fmap (map uToString . toList . QL.frame) backtrace+        r = map utf8 $ toList response+        e = fromMaybe "error" $ fmap uToString error_message++showBacktrace :: [String] -> String+showBacktrace [] = "query"+showBacktrace bt = ("in " ++ ) . concat . (++ [" query"]) .+                   intersperse " " . map f . reverse $ bt+  where f x = x ++ " in"++-- | Execute a raw protobuffer query and return the raw response+runQLQuery :: RethinkDBHandle -> QL.Query -> IO Response+runQLQuery h query = do+  let queryS = messagePut query+  sendAll h $ packUInt (fromIntegral $ B.length queryS) <> queryS+  fmap convertResponse $ readResponse (QLQuery.token query)+  +  where readResponse t = do+          header <- recvAll h 4+          responseS <- recvAll h (unpackUInt header)+          let eResponse = messageGet responseS+          case eResponse of+            Left errMsg -> return $ Left errMsg+            Right (response, rest)+              | B.null rest ->+                (case QLResponse.token response of+                  n | n == t -> return $ Right response+                    | n > t -> return $ Left "RethinkDB: runQLQuery: invalid response token"+                    | otherwise -> readResponse t)+              | otherwise -> return $ Left "RethinkDB: runQLQuery: invalid reply length"++-- * CRUD++-- | A database, referenced by name+data Database = Database {+  databaseName :: String+  } deriving (Eq, Ord)++instance Show Database where+  show (Database d) = show d++-- | Create a Database reference+db :: String -> Database+db s = Database s++-- | Create a database on the server+dbCreate :: String -> Query False Database+dbCreate db_name = Query+  (metaQuery $ return $ QL.MetaQuery QL.CREATE_DB (Just $ uFromString db_name) Nothing Nothing)+  (const $ Right $ Database db_name)++-- | Drop a database+dbDrop :: Database -> Query False ()+dbDrop (Database name) = Query+  (metaQuery $ return $ QL.MetaQuery QL.DROP_DB (Just $ uFromString name) Nothing Nothing)+  (const $ Right ())++-- | List the databases on the server+-- +-- >>> run h $ dbList+-- [test, dev, prod]++dbList :: Query False [Database]+dbList = Query+  (metaQuery $ return $ QL.MetaQuery QL.LIST_DBS Nothing Nothing Nothing)+  (maybe (Left "error") Right . sequence . map (fmap Database . convert))++-- | Options used to create a table+data TableCreateOptions = TableCreateOptions {+  tableDataCenter :: Maybe String,+  tableCacheSize :: Maybe Int64+  }++instance Default TableCreateOptions where+  def = TableCreateOptions Nothing Nothing++-- | A table description+data Table = Table {+  tableDatabase :: Maybe Database, -- ^ when Nothing, use the rdbDatabase+  tableName :: String,+  _tablePrimaryAttr :: Maybe String -- ^ when Nothing, "id" is used+  } deriving (Eq, Ord)++instance Show Table where+  show (Table db' nam pa) =+    maybe "" (\(Database d) -> d++".") db' ++ nam ++ maybe "" (\x -> "{"++x++"}") pa++tablePrimaryAttr :: Table -> String+tablePrimaryAttr = fromMaybe (uToString defaultPrimaryAttr) . _tablePrimaryAttr++-- | "id"+defaultPrimaryAttr :: Utf8+defaultPrimaryAttr = uFromString "id"++-- | Create a simple table refence with no associated database or primary key+-- +-- >>> table "music"+-- +-- Another way to create table references is to use the Table constructor:+-- +-- >>> Table (Just "mydatabase") "music" (Just "tuneid")++table :: String -> Table+table n = Table Nothing n Nothing++-- | Create a table on the server+-- +-- @def@ can be imported from Data.Default+-- +-- >>> t <- run h $ tableCreate (table "fruits") def++tableCreate :: Table -> TableCreateOptions -> Query False Table+tableCreate (Table mdb table_name primary_key)+  (TableCreateOptions datacenter cache_size) = Query+  (metaQuery $ do +      curdb <- activeDB+      let create = defaultValue {+        QLCreateTable.datacenter = fmap uFromString datacenter,+        QLCreateTable.table_ref = QL.TableRef (uFromString $ databaseName $ fromMaybe curdb mdb)+                                  (uFromString table_name) Nothing, +        QLCreateTable.primary_key = fmap uFromString primary_key,+        QLCreateTable.cache_size = cache_size+        }+      return $ QL.MetaQuery QL.CREATE_TABLE Nothing (Just create) Nothing)+               (const $ Right $ Table mdb table_name primary_key)++-- | Drop a table+tableDrop :: Table -> Query False ()+tableDrop tbl = Query+  (metaQuery $ do+      ref <- tableRef tbl+      return $ QL.MetaQuery QL.DROP_TABLE Nothing Nothing $ Just $ ref)+  (const $ Right ())++-- | List the tables in a database+tableList :: Database -> Query False [Table]+tableList (Database name) = Query +  (metaQuery $ return $ +    QL.MetaQuery QL.LIST_TABLES (Just $ uFromString name) Nothing Nothing)+  (maybe (Left "error") Right . sequence .+   map (fmap (\x -> Table (Just (Database name)) x Nothing) . convert))++-- | Get the primary key of the table as a Utf8, or "id" if there is none+uTableKey :: Table -> Utf8+uTableKey (Table _ _ mkey) = fromMaybe defaultPrimaryAttr $ fmap uFromString mkey++-- | A reference to a document+data Document = Document {+  documentTable :: Table,+  documentKey :: Value+  } deriving (Eq)++instance Show Document where+  show (Document t k) = show t ++ "[" ++ show k ++ "]"++-- | Get a document by primary key+get :: (ToExpr e, ExprType e ~ StreamType True ObjectType, ToValue k) =>+       e -> k -> ObjectExpr+get e k = Expr $ do+  (vw, _) <- exprV e+  let tbl@(Table _ _ mattr) = viewTable vw+  ref <- tableRef tbl+  key <- value k+  withView NoView $ return defaultValue {+    QL.type' = QL.GETBYKEY,+    QL.get_by_key = Just $ QL.GetByKey ref (fromMaybe defaultPrimaryAttr $+                                            fmap uFromString mattr) key+    }++insert_or_upsert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>+                    Table -> [a] -> Bool -> WriteQuery [Document]+insert_or_upsert tbl array overwrite = WriteQuery+  (do ref <- tableRef tbl+      as <- mapM value array+      let write = defaultValue {+          QLWriteQuery.type' = QL.INSERT,+          QL.insert = Just $ QL.Insert ref+                      (Seq.fromList $ as) (Just overwrite) }+      return $ write)+  (whenSuccess "generated_keys" $ \keys -> Right $ map (\doc -> Document tbl doc) keys)++-- | Insert a document into a table+-- +-- >>> d <- run h $ insert t (object ["name" .= "banana", "color" .= "red"])++insert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>+          Table -> a -> WriteQuery Document+insert tb a = fmap head $ insert_or_upsert tb [a] False++-- | Insert many documents into a table+insertMany :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>+              Table -> [a] -> WriteQuery [Document]+insertMany tb a = insert_or_upsert tb a False++-- | Insert a document into a table, overwriting a document with the+--   same primary key if one exists.++upsert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>+          Table -> a -> WriteQuery Document+upsert tb a = fmap head $ insert_or_upsert tb [a] True++-- | Insert many documents into a table, overwriting any existing documents +--   with the same primary key.+upsertMany :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>+              Table -> [a] -> WriteQuery [Document]+upsertMany tb a = insert_or_upsert tb a True++-- | Update a table+-- +-- >>> t <- run h $ tableCreate (table "example") def+-- >>> run h $ insertMany t [object ["a" .= 1, "b" .= 11], object ["a" .= 2, "b" .= 12]]+-- >>> run h $ update t (object ["b" .= 20])+-- >>> run h $ t++update :: (ToExpr sel, ExprType sel ~ StreamType True out, ToMapping map,+           MappingFrom map ~ out, MappingTo map ~ ObjectType) =>+          sel -> map -> WriteQuery ()+update view m = WriteQuery+  (do mT <- mapping m+      write <- case toExpr view of+        Expr _ -> do viewT <- expr view+                     return defaultValue {+                       QLWriteQuery.type' = QL.UPDATE,+                       QL.update = Just $ QL.Update viewT mT }+        SpotExpr (Document tbl@(Table _ _ k) d) -> do+          ref <- tableRef tbl+          return $ defaultValue {+            QLWriteQuery.type' = QL.POINTUPDATE,+            QL.point_update = Just $ QL.PointUpdate ref+                              (fromMaybe defaultPrimaryAttr $ fmap uFromString k)+                              (toJsonTerm d) mT }+      return write)+  (whenSuccess_ ())++-- | Replace documents in a table+replace :: (ToExpr sel, ExprIsView sel ~ True, ToJSON a) => sel -> a -> WriteQuery ()+replace view a = WriteQuery+  (do fun <- mapping (toJSON a)+      write <- case toExpr view of+        Expr f -> do+          (_, e) <- f+          return defaultValue {+            QLWriteQuery.type' = QL.MUTATE,+            QL.mutate = Just $ QL.Mutate e fun }+        SpotExpr (Document tbl@(Table _ _ k) d) -> do+          ref <- tableRef tbl+          return defaultValue {+            QLWriteQuery.type' = QL.POINTMUTATE,+            QL.point_mutate = Just $ QL.PointMutate ref+                              (fromMaybe defaultPrimaryAttr $ fmap uFromString k)+                              (toJsonTerm d) fun }+      return write)+  (whenSuccess_ ())++-- | Delete one or more documents from a table+delete :: (ToExpr sel, ExprIsView sel ~ True) => sel -> WriteQuery ()+delete view = WriteQuery+  (do write <- case toExpr view of+          Expr f -> do+            (_, ex) <- f+            return defaultValue {+              QLWriteQuery.type' = QL.DELETE,+              QL.delete = Just $ QL.Delete ex }+          SpotExpr (Document tbl@(Table _ _ k) d) -> do+            ref <- tableRef tbl+            return defaultValue {+              QLWriteQuery.type' = QL.POINTDELETE,+              QL.point_delete = Just $ QL.PointDelete ref+                              (fromMaybe defaultPrimaryAttr $ fmap uFromString k)+                              (toJsonTerm d) }+      return write)+  (whenSuccess_ ())++-- * Queries++-- | A query returning a+data Query (b :: Bool) a where+  Query :: { _queryBuild :: QueryM QL.Query, +             _queryExtract :: [Value] -> Either String a } -> Query False a+  ViewQuery ::  { _viewQueryBuild :: QueryM (Table, QL.Query),+                  _viewQueryExtract :: [(Document, Value)] -> Either String a }+                -> Query True a++data WriteQuery a = WriteQuery {+  writeQueryBuild :: QueryM QL.WriteQuery,+  writeQueryExtract :: [Value] -> Either String a+  }++queryBuild :: Query w a -> QueryM (MaybeView w, QL.Query)+queryBuild (Query b _) = fmap ((,) NoView) b+queryBuild (ViewQuery b _) = fmap (first ViewOf) b++queryExtract :: Query w a -> MaybeView w -> [Value] -> Either String a+queryExtract (Query _ e)     _            vs = e vs+queryExtract (ViewQuery _ e) (ViewOf tbl) vs = e =<< mapM (addDoc tbl) vs+queryExtract _ _ _ = error "GHC was right, this branch is reachable!"++instance Functor (Query w) where+  fmap f (Query a g) = Query a (fmap f . g)+  fmap f (ViewQuery a g) = ViewQuery a (fmap f . g)++instance Functor WriteQuery where+  fmap f (WriteQuery a g) = WriteQuery a (fmap f . g)+++type family If (p :: Bool) (a :: k) (b :: k) :: k+type instance If True  a b = a+type instance If False a b = b+++-- | Convert things like tables and documents into queries+class ToBuildQuery a where+  type BuildViewQuery a :: Bool+  buildQuery :: a -> ([If (BuildViewQuery a)+                       (Document, Value) Value]+                      -> Either String b) -> Query (BuildViewQuery a) b++class ToBuildQuery a => ToQuery a b | a -> b where+  toQuery :: a -> Query (BuildViewQuery a) b++instance ToBuildQuery (Query w a) where+  type BuildViewQuery (Query w a) = w+  buildQuery (Query b _) = Query b+  buildQuery (ViewQuery b _) = ViewQuery b++instance ToQuery (Query w a) a where+  toQuery q = q++instance ToBuildQuery (WriteQuery a) where+  type BuildViewQuery (WriteQuery a) = False+  buildQuery (WriteQuery b _) = Query $ do+    wq <- b+    tok <- getToken+    return $ defaultValue { QLQuery.type' = QL.WRITE, QLQuery.token = tok, +                            QLQuery.write_query = Just $ wq }  ++instance ToQuery (WriteQuery a) a where+  toQuery w@(WriteQuery _ e) = buildQuery w e++instance ToBuildQuery Table where+  type BuildViewQuery Table = True+  buildQuery = buildQuery . toExpr++instance FromJSON a => ToQuery Table [(Document, a)] where+  toQuery tbl = buildQuery tbl $+    (maybe (Left "wrong response type") Right . mapMSnd convert)++mapMSnd :: Monad m => (a -> m b) -> [(c,a)] -> m [(c,b)]+mapMSnd f = mapM $ \(a,b) -> liftM ((,) a) (f b)++instance ToBuildQuery Document where+  type BuildViewQuery Document = True+  buildQuery = buildQuery . toExpr++instance FromJSON a => ToQuery Document a where+  toQuery doc = buildQuery doc $+    maybe (Left "empty response") Right . ((convert . snd) <=< listToMaybe)++data Proxy t = Proxy++instance ToBuildQuery (Expr (StreamType False v)) where+  type BuildViewQuery (Expr (StreamType False v)) = False+  buildQuery = Query . fmap snd . exprToQLQuery++instance ExtractValue v a => ToQuery (Expr (StreamType False v)) [a] where+  toQuery e = buildQuery e $+              maybe (Left "cannot convert response") Right+              . extractListOf (Proxy :: Proxy v)++instance ToBuildQuery (Expr (StreamType True v)) where+  type BuildViewQuery (Expr (StreamType True v)) = True+  buildQuery = ViewQuery . fmap (first viewTable) . exprToQLQuery++instance ExtractValue v a => ToQuery (Expr (StreamType True v)) [(Document, a)] where+  toQuery e = exprViewQuery (maybe (Left "cannot convert response") Right . extract) e+    where extract = extractListOf (Proxy :: Proxy v)++instance ToBuildQuery (Expr (ValueType v)) where+  type BuildViewQuery (Expr (ValueType v)) = False+  buildQuery = Query . fmap snd . exprToQLQuery++instance ExtractValue v a => ToQuery (Expr (ValueType v)) a where+  toQuery e = buildQuery e $ +              maybe (Left "empty response")+                (maybe (Left "cannot convert response") Right .+                 extractValue (Proxy :: Proxy v))+              . listToMaybe++exprToQLQuery :: Expr t -> QueryM (MaybeView (ExprTypeIsView t), QL.Query)+exprToQLQuery e = do+  token <- getToken+  (vw, ex) <- exprV e+  return $ (,) vw $ QL.Query QL.READ token (+    Just $ defaultValue { QLReadQuery.term = ex }) Nothing Nothing++exprViewQuery :: (ExprTypeIsView t ~ True) =>+                 ([Value] -> Either String [a]) -> Expr t -> Query True [(Document, a)]+exprViewQuery c e = flip ViewQuery (\x -> fmap (zip $ map fst x) (c (map snd x))) $ do+  token <- getToken+  (ViewOf tbl, ex) <- exprV e+  return $ (,) tbl $ QL.Query QL.READ token (+    Just $ defaultValue { QLReadQuery.term = ex }) Nothing Nothing++extractListOf :: ExtractValue t a => Proxy t -> [Value] -> Maybe [a]+extractListOf p = sequence . map (extractValue p)++class ExtractValue t v | t -> v where+  extractValue :: Proxy t -> Value -> Maybe v++instance (Num a, FromJSON a) => ExtractValue NumberType a where extractValue _ = convert+instance ExtractValue BoolType Bool where extractValue _ = convert+instance FromJSON a => ExtractValue ObjectType a where extractValue _ = convert+instance FromJSON a => ExtractValue ArrayType a where extractValue _ = convert+instance (IsString a, FromJSON a) => ExtractValue StringType a where extractValue _ = convert+instance ExtractValue NoneType () where extractValue _ = const $ Just ()+instance FromJSON a => ExtractValue OtherValueType a where extractValue _ = convert++-- | Run a query on the connection+-- +-- The return value depends on the type of the second argument.+-- +-- When the return value is polymorphic, type annotations may be required.+-- +-- >>> run h $ table "fruits" :: IO [(Document, Value)]++run :: ToQuery a v => RethinkDBHandle -> a -> IO v+run h q = do+  r <- runEither h q+  case r of+    Left e -> error e+    Right a -> return a++-- | Run a query on the connection, returning (Left message) on error+runEither :: ToQuery a v => RethinkDBHandle -> a -> IO (Either String v)+runEither h q = case toQuery q of+  -- TODO: just call runBatch and get the resultsSeq+  query -> do+    tok <- getNewToken h+    let ((vw, qlq), _) = runQueryM (queryBuild query) $+                    QuerySettings tok (rdbDatabase h) initialVars False+    r <- runQLQuery h qlq+    return $ case r of+      ErrorResponse {} -> Left (show r)+      SuccessResponse _ strs -> queryExtract query vw =<<+       (maybe (Left "decode error") Right . sequence . map decodeAny $ strs)++addDoc :: Table -> Value -> Either String (Document, Value)+addDoc tbl x = do+  id' <- maybe (Left "missign primary key") Right $ getKey (tablePrimaryAttr tbl) x+  return (Document tbl id', x)+  where getKey k (Object o) = parseMaybe (.: str k) o+        getKey _ _ = Nothing++-- | Run a query on the connection, returning Nothing on error+runMaybe :: ToQuery a v => RethinkDBHandle -> a -> IO (Maybe v)+runMaybe h = fmap (either (const Nothing) Just) . runEither h++-- | Run a query on the connection and return the raw response+runRaw :: (ToBuildQuery q, JSONQuery (BuildViewQuery q)) =>+          RethinkDBHandle -> q -> IO Response+runRaw h q = do+  tok <- getNewToken h+  let ((_, qlq), _) = runQueryM (queryBuild (jsonQuery (buildQuery q))) $+                      QuerySettings tok (rdbDatabase h) initialVars False+  runQLQuery h qlq++-- | Run a query on the connection and return the resulting JSON value+runJSON :: (JSONQuery (BuildViewQuery q), ToBuildQuery q) =>+           RethinkDBHandle -> q -> IO [Value]+runJSON h q = run h (jsonQuery (buildQuery q))++class JSONQuery (b :: Bool) where+  jsonQuery :: (forall a . ([If b (Document, Value) Value] -> Either String a) -> Query b a)+               -> Query b [Value]++instance JSONQuery False where+  jsonQuery f = f Right++instance JSONQuery True where+  jsonQuery f = f (Right . map snd)++data Results a = Results {+  resultsHandle :: IORef (Maybe (RethinkDBHandle, Int64)),+  resultsSeq :: IORef (Seq.Seq a),+  _resultsError :: IORef (Maybe String),+  resultsQueryView :: QueryViewPair [a]+  }++data QueryViewPair a where+  QueryViewPair :: Query w a -> MaybeView w -> QueryViewPair a++-- | Run a query on the connection and a return a lazy result list+-- +-- >>> res <- runBatch h <- (arrayToStream [1,2,3] :: NumberStream)+-- >>> next res+-- Just 1+-- >>> collect res+-- [2,3]++runBatch :: ToQuery q [a] => RethinkDBHandle -> q -> IO (Results a)+runBatch h q = case toQuery q of+  query -> do+    tok <- getNewToken h+    let ((vw, qlq), _) = runQueryM (queryBuild query) $+                    QuerySettings tok (rdbDatabase h) initialVars False+    r <- runQLQuery h qlq+    let (han, seq', err) = queryExtractResponse query vw r h tok+    refHan <- newIORef han+    refSeq <- newIORef seq'+    refErr <- newIORef err+    return $ Results refHan refSeq refErr (QueryViewPair query vw)++queryExtractResponse ::+  Query w [a] -> MaybeView w -> Response -> RethinkDBHandle -> Int64+  -> (Maybe (RethinkDBHandle, Int64), Seq a, Maybe String)+queryExtractResponse query vw r h tok =+    case r of+      ErrorResponse {} -> (Nothing, Seq.fromList [], Just $ show r)+      SuccessResponse typ strs ->+        let rList = queryExtract query vw =<<+               (maybe (Left "decode error") Right . sequence . map decodeAny $ strs)+        in case rList of+          Left err -> (Nothing, Seq.fromList [], Just err)+          Right list ->+            let han = case typ of+                  SuccessPartial -> Just (h, tok)+                  SuccessStream -> Nothing+                  SuccessJson -> Nothing+                  SuccessEmpty -> Nothing+            in (han, Seq.fromList list, Nothing)++-- | Read the next value from a lazy query. Fetch it from the server if needed.+next :: Results a -> IO (Maybe a)+next res = do+  seq' <- readIORef (resultsSeq res)+  case Seq.viewl seq' of+    car Seq.:< cdr -> do+      writeIORef (resultsSeq res) cdr+      return (Just car)+    Seq.EmptyL -> do+      mh <- readIORef (resultsHandle res)+      case (mh, resultsQueryView res) of+        (Nothing, _) -> return Nothing+        (Just (h, tok), (QueryViewPair query vw)) -> do+          resp <- runQLQuery h $ defaultValue {+            QLQuery.type' = QL.CONTINUE, QLQuery.token = tok }+          let (han, seq'', err) = queryExtractResponse query vw resp h tok+          writeIORef (resultsHandle res) han+          modifyIORef (resultsSeq res) (<> seq'')+          writeIORef (_resultsError res) err+          next res++-- | Return all the results of a lazy query.+collect :: Results a -> IO [a]+collect r = do+  ma <- next r+  case ma of+    Nothing -> return []+    Just a -> fmap (a:) (collect r)++-- | Get the last error from a lazy query.+-- +-- If both next and resultsError return Nothing, then+-- all results have been fetched without error.++resultsError :: Results a -> IO (Maybe String)+resultsError = readIORef . _resultsError++-- * Expressions++-- | Can the Expr be written to? (updated or deleted)+type family ExprTypeIsView (expr :: ExprTypeKind) :: Bool+type instance ExprTypeIsView (StreamType w o) = w+type instance ExprTypeIsView (ValueType v) = False++type ExprIsView e = ExprTypeIsView (ExprType e)++type family ExprTypeNoView (t :: ExprTypeKind) :: ExprTypeKind+type instance ExprTypeNoView (StreamType b t) = StreamType False t+type instance ExprTypeNoView (ValueType t) = ValueType t++-- | The type of the value of an Expr+type family ExprValueType expr :: ValueTypeKind+type instance ExprValueType (Expr (ValueType v)) = v+type instance ExprValueType (Expr (StreamType w v)) = v++-- | The type of the stream of an Expr+type family ExprTypeStreamType (t :: ExprTypeKind) :: ValueTypeKind+type instance ExprTypeStreamType (StreamType w t) = t++-- | An RQL expression+data Expr (t :: ExprTypeKind) where+  Expr :: QueryM (MaybeView (ExprIsView (Expr t)), QL.Term) -> Expr t+  SpotExpr :: Document -> Expr (StreamType True ObjectType)++mkExpr :: ExprIsView (Expr t) ~ False => QueryM QL.Term -> Expr t+mkExpr q = Expr $ fmap ((,) NoView) q++mkView :: ExprIsView (Expr t) ~ True => Table -> QueryM QL.Term -> Expr t+mkView t q = Expr $ fmap ((,) (ViewOf t)) q++viewKeyAttr :: MaybeView b -> Utf8+viewKeyAttr v = fromMaybe defaultPrimaryAttr $ fmap uFromString $+    case v of +      ViewOf (Table _ _ k) -> k+      NoView -> Nothing++viewTable :: MaybeView True -> Table+viewTable v = case v of ViewOf t -> t++data MaybeView (w :: Bool) where+ NoView :: MaybeView False+ ViewOf :: Table -> MaybeView True++-- | Convert something into an Expr+class ToExpr (o :: *) where+  type ExprType o :: ExprTypeKind+  toExpr :: o -> Expr (ExprType o)++-- | The result type of toValue+type family ToValueType (t :: ExprTypeKind) :: ValueTypeKind+type instance ToValueType (StreamType w t) = ArrayType+type instance ToValueType (ValueType t) = t++-- | Convert something into a value Expr+class ToValue e where+  toValue :: e -> Expr (ValueType (ToValueType (ExprType e)))++type family FromMaybe (a :: k) (m :: Maybe k) :: k+type instance FromMaybe a Nothing = a+type instance FromMaybe a (Just b) = b++type HasToStreamValueOf a b = FromMaybe a (ToStreamValue b) ~ a++type ToStreamValue e = ToStreamTypeValue (ExprType e)++type family ToStreamTypeValue (t :: ExprTypeKind) :: Maybe ValueTypeKind+type instance ToStreamTypeValue (StreamType w t) = Just t+type instance ToStreamTypeValue (ValueType t) = Nothing++class ToExpr e => ToStream e where+  toStream :: e -> Expr (StreamType (ExprIsView e) (FromMaybe a (ToStreamValue e)))++instance ToExpr Document where+  type ExprType Document = StreamType True 'ObjectType+  toExpr doc = SpotExpr doc++instance ToValue Document where+  toValue = streamToArray++instance ToStream Document where+  toStream = toExpr++instance ToExpr Table where+  type ExprType Table = StreamType True ObjectType+  toExpr tbl = mkView tbl $ do+    ref <- tableRef tbl+    return defaultValue { +      QL.type' = QL.TABLE,+      QL.table = Just $ QL.Table ref }++instance ToValue Table where+  toValue = streamToArray+                                  +instance ToStream Table where+  toStream = toExpr++instance ToExpr (Expr t) where+  type ExprType (Expr t) = t+  toExpr e = e++instance ToValue (Expr (ValueType t)) where+  toValue e = e++instance ToValue (Expr (StreamType w t)) where+  toValue = streamToArray++instance ToStream (Expr (ValueType ArrayType)) where+  toStream = arrayToStream++instance ToStream (Expr (StreamType w t)) where+  toStream e = e++instance ToExpr Int where+  type ExprType Int = ValueType NumberType+  toExpr n = mkExpr $ return $ defaultValue {+    QL.type' = QL.NUMBER, QL.number = Just $ fromIntegral n }++instance ToValue Int where+  toValue = toExpr+  +instance ToExpr Integer where+  type ExprType Integer = ValueType NumberType+  toExpr n = mkExpr $ return $ defaultValue {+    QL.type' = QL.NUMBER, QL.number = Just $ fromInteger n }++instance ToValue Integer where+  toValue = toExpr++instance ToExpr Double where+  type ExprType Double = ValueType NumberType+  toExpr n = mkExpr $ return $ defaultValue {+    QL.type' = QL.NUMBER, QL.number = Just n }++instance ToValue Double where+  toValue = toExpr++instance ToExpr Char where+  type ExprType Char = ValueType StringType+  toExpr c = mkExpr $ return defaultValue {+    QL.type' = QL.STRING, QL.valuestring = Just $ uFromString [c] }++instance ToExpr T.Text where+  type ExprType T.Text = ValueType StringType+  toExpr s = mkExpr $ return defaultValue {+    QL.type' = QL.STRING, QL.valuestring = Just $ uFromString (T.unpack s) }++instance ToValue T.Text where+  toValue = toExpr++str :: String -> T.Text+str = T.pack++instance ToExpr a => ToExpr [a] where+  type ExprType [a] = ValueType ArrayType+  toExpr l = mkExpr $ do+    exs <- sequence $ map (expr . toExpr) l+    return defaultValue {+      QL.type' = QL.ARRAY, QL.array = Seq.fromList exs }++instance ToExpr a => ToValue [a] where+  toValue = toExpr++instance ToExpr a => ToStream [a] where+  toStream = arrayToStream . toExpr++instance ToExpr () where+  type ExprType () = ValueType NoneType+  toExpr () = mkExpr $ return $  defaultValue { QL.type' = QL.JSON_NULL }++instance ToValue () where+  toValue = toExpr++instance ToExpr Obj where+  type ExprType Obj = ValueType ObjectType+  toExpr (Obj o) = mkExpr $ do+    exs <- sequence $ map go o+    return defaultValue {+      QL.type' = QL.OBJECT, QL.object = Seq.fromList exs }+    where go (k := a) = do+            ex <- value a+            return QL.VarTermTuple {+              QLVarTermTuple.var = uFromString k, QLVarTermTuple.term = ex }++instance ToValue Obj where+  toValue = toExpr++-- | Aliases for type constraints on expressions+type HasValueType a v = (ToValue a, ToValueType (ExprType a) ~ v)+type HaveValueType a b v = (HasValueType a v, HasValueType b v)++-- | Simple aliases for different Expr types+type NumberExpr = Expr (ValueType NumberType)+type BoolExpr = Expr (ValueType BoolType)+type ObjectExpr = Expr (ValueType ObjectType)+type ArrayExpr = Expr (ValueType ArrayType)+type StringExpr = Expr (ValueType StringType)+type ValueExpr t = Expr (ValueType t)+type NumberStream = Expr (StreamType False NumberType)+type BoolStream = Expr (StreamType False BoolType)+type ArrayStream = Expr (StreamType False ArrayType)+type StringStream = Expr (StreamType False StringType)+type ObjectStream = Expr (StreamType False ObjectType)+type Selection = Expr (StreamType True ObjectType)++-- | What values can be compared with eq, ne, lt, gt, le and ge+class CanCompare (a :: ValueTypeKind)+instance CanCompare NumberType+instance CanCompare StringType++instance Num (Expr (ValueType NumberType)) where+  (+) = add+  (-) = sub+  (*) = mul+  abs = jsfun "abs"+  signum = signum'+  fromInteger = toExpr++instance Fractional (Expr (ValueType NumberType)) where+  fromRational n = toExpr (fromRational n :: Double)+  (/) = div'++-- | A sequence is either a stream or an array+class Sequence (e :: ExprTypeKind) where+  type SequenceType e (t :: ValueTypeKind) :: Constraint++instance Sequence (StreamType w t) where+  type SequenceType (StreamType w t) tt = t ~ tt++instance a ~ ArrayType => Sequence (ValueType a) where+  type SequenceType (ValueType a) t = ()++-- | A list of String/Expr pairs+data Obj = Obj [Attribute]+data Attribute = forall e . (ToValue e) => String := e++-- | Build an Obj+obj :: [Attribute] -> Obj+obj = Obj++-- | Convert a stream into an array++streamToArray :: (ToExpr e, ExprType e ~ StreamType w t) => e -> Expr (ValueType ArrayType)+streamToArray = simpleOp QL.STREAMTOARRAY . return . expr++-- | Convert an array into a stream+arrayToStream :: (ToExpr e, ExprType e ~ ValueType ArrayType) => e -> Expr (StreamType False t)+arrayToStream = simpleOp QL.ARRAYTOSTREAM . return . expr++-- * Mappings++-- | A mapping is a like single-parameter function+data Mapping (from :: ValueTypeKind) (to :: ValueTypeKind) =+  Mapping (QueryM QL.Mapping)++-- | Convert objects into mappings+class ToMapping map where+  type MappingFrom map :: ValueTypeKind+  type MappingTo map :: ValueTypeKind+  toMapping :: map -> Mapping (MappingFrom map) (MappingTo map)++instance ToMapping Obj where+  type MappingFrom Obj = ObjectType+  type MappingTo Obj = ObjectType+  toMapping v = Mapping $ do +    ex <- expr v+    return $ defaultValue { QLMapping.body = ex }++instance ToMapping Value where+  type MappingFrom Value = ObjectType+  type MappingTo Value = ObjectType+  toMapping v = Mapping $ return $ defaultValue { QLMapping.body = toJsonTerm v }++instance (ToValue b, a ~ Expr (ValueType t)) => ToMapping (a -> b) where +  type MappingFrom (a -> b) = ExprValueType a+  type MappingTo (a -> b) = ToValueType (ExprType b)+  toMapping f = Mapping $ do+    v <- newVar+    ex <- value (f (var v))+    return $ defaultValue {+      QLMapping.arg = uFromString v,+      QLMapping.body = ex }++instance ToMapping (Expr (ValueType t)) where+  type MappingFrom (Expr (ValueType t)) = ObjectType+  type MappingTo (Expr (ValueType t)) = t+  toMapping e = Mapping $ do +    ex <- expr e+    return defaultValue { QLMapping.body = ex }++-- * QueryM Monad++data QuerySettings = QuerySettings {+  _queryToken :: Int64,+  _queryDB :: Database,+  _queryVars :: [String],+  _queryUseOutdated :: Bool+  }++instance Default QuerySettings where+  def = QuerySettings 0 (db "") initialVars False++type QueryM = State QuerySettings++runQueryM :: QueryM a -> QuerySettings -> (a, QuerySettings)+runQueryM = runState++initialVars :: [String]+initialVars = concat $ zipWith (\n as -> map (++ (if n == 0 then "" else show n)) as)+              [0 :: Int ..] (map (map return) $ repeat ['a'..'z'])++getToken :: QueryM Int64+getToken = fmap _queryToken S.get++activeDB :: QueryM Database+activeDB = fmap _queryDB S.get++newVar :: QueryM String+newVar  = state $ \s -> let (x:xs) = _queryVars s in (x, s { _queryVars = xs} )++setUseOutdated :: ToExpr e => Bool -> e -> Expr (ExprType e)+setUseOutdated b e = Expr $ do+  state $ \s -> runQueryM (exprV e) s { _queryUseOutdated = b }++-- * Utilities++-- | Convert a protobuf Mapping into a Predicate+mappingToPredicate :: QL.Mapping -> QL.Predicate+mappingToPredicate (QL.Mapping arg body _1) = defaultValue {+  QLPredicate.arg = arg,+  QLPredicate.body = body+  }++-- | Convert a table to a raw protobuf term+tableToTerm :: Table -> QueryM QL.Term+tableToTerm tbl = do+  ref <- tableRef tbl+  return $ defaultValue {+    QL.type' = QL.TABLE,+    QL.table = Just $ QL.Table ref }++-- | Convert into a raw protobuf mapping+mapping :: ToMapping m => m -> QueryM QL.Mapping+mapping m = case toMapping m of Mapping f -> f++-- | Convert an Expr to a term+expr ::  ToExpr e => e -> QueryM QL.Term+expr = fmap snd . exprV++exprV :: ToExpr e => e -> QueryM (MaybeView (ExprIsView e), QL.Term)+exprV e = case toExpr e of+  Expr f -> f+  SpotExpr (Document tbl@(Table _ _ mkey) d) -> do+    ref <- tableRef tbl+    return $ ((,) (ViewOf tbl)) defaultValue { +      QL.type' = QL.GETBYKEY,+      QL.get_by_key = Just $ QL.GetByKey ref+             (fromMaybe defaultPrimaryAttr $ fmap uFromString mkey)+             (toJsonTerm d) }++-- | Convert a stream to a term+stream :: ToStream a => a -> QueryM QL.Term+stream = expr . toStream++-- | Convert a value to a term+value :: ToValue a => a -> QueryM QL.Term+value = expr . toValue++-- | build a raw protobuf Term+toJsonTerm :: ToJSON a => a -> QL.Term+toJsonTerm a = defaultValue {+  QL.type' = QL.JSON,+  QL.jsonstring = Just $ Utf8 (encode a)+  }++-- | Test if a field is present in a json Value and return it+(.?) :: FromJSON a => Value -> String -> Maybe a+(.?) (Object h) k = toMaybe . fromJSON =<< HM.lookup (T.pack k) h+  where toMaybe (Success a) = Just a+        toMaybe _ = Nothing+(.?) _ _ = Nothing++-- | Helper function to handle responses to a query+whenSuccess :: FromJSON a => String -> (a -> Either String b) -> [Value] -> Either String b+whenSuccess key f response = do+  info <- maybe (Left "invalid response") Right (convert =<< listToMaybe response)+  if info .? "errors" /= Just (0 :: Int)+    then maybe (Left "unknown error") Left $ info .? "first_error"+    else fromMaybe (Left "key missing in response") (fmap f (info .? key))++-- | same as whenSuccess, but ignore the response when there is no error+whenSuccess_ :: b -> [Value] -> Either String b+whenSuccess_ b response = do+  info <- maybe (Left "invalid response") Right (convert =<< listToMaybe response)+  if info .? "errors" /= Just (0 :: Int)+    then maybe (Left "unknown error") Left $ info .? "first_error"+    else Right b++-- | Like aeson's decode, but but works on numbers and strings, not only objects and arrays+decodeAny :: FromJSON a => ByteString -> Maybe a+decodeAny s =+  case Attoparsec.parse Data.Aeson.Parser.value s of+    Attoparsec.Done _ v -> convert v+    _          -> Nothing++-- | Convert a JSON Value into another type+convert :: FromJSON a => Value -> Maybe a+convert v = case fromJSON v of+  Success a -> Just a+  _         -> Nothing++-- | Extract the error message from a Response if there is an error+-- | Help build meta queries+metaQuery :: QueryM QL.MetaQuery -> QueryM QL.Query+metaQuery q = do+  t <- getToken+  mq <- q+  return $ QL.Query QL.META t Nothing Nothing $ Just mq++-- | Convert an int to a 4-byte bytestring+packUInt :: Int -> ByteString+packUInt n = pack $ map fromIntegral $ +               [n `mod` 256, (n `shiftR` 8) `mod` 256,+                (n `shiftR` 16) `mod` 256, (n `shiftR` 24) `mod` 256]++-- | Convert a 4-bte byestring to an int+unpackUInt :: ByteString -> Int+unpackUInt s = case unpack s of+  [a,b,c,d] -> fromIntegral a .|.+               fromIntegral b `shiftL` 8 .|.+               fromIntegral c `shiftL` 16 .|.+               fromIntegral d `shiftL` 24+  _ -> error "unpackUInt: lengh is not 4"++op :: QL.BuiltinType -> QLBuiltin.Builtin+op o = defaultValue { QLBuiltin.type' = o }++apply :: QL.Builtin -> [QueryM QL.Term] -> QueryM QL.Term+apply o args = do+  a <- sequence args+  return $ defaultValue { QL.type' = QL.CALL, QL.call = Just $ QL.Call o (Seq.fromList a) }++rapply :: [QueryM QL.Term] -> QL.Builtin -> QueryM QL.Term+rapply = flip apply++simpleOp :: ExprIsView (Expr t) ~ False => QL.BuiltinType -> [QueryM QL.Term] -> Expr t+simpleOp o a = mkExpr $ apply (op o) a++withView :: MaybeView b -> QueryM QL.Term -> QueryM (MaybeView b, QL.Term)+withView v = fmap ((,) v)++primaryAttr :: (ToExpr e, ExprTypeIsView (ExprType e) ~ True) =>+               e -> String -> Expr (ExprType e)+primaryAttr e a = Expr $ do+  (ViewOf (Table mdb name _), ex) <- exprV e+  return (ViewOf (Table mdb name (Just a)), ex)++comparison :: ExprTypeIsView t ~ False => QL.Comparison -> [QueryM QL.Term] -> Expr t+comparison o a = mkExpr $ rapply a (op QL.COMPARE) { QL.comparison = Just o }++-- | Build a protobuf TableRef object+tableRef :: Table -> QueryM QL.TableRef+tableRef (Table mdb tb _) = do+  curdb <- activeDB+  useOutdated <- fmap _queryUseOutdated S.get+  return $ QL.TableRef (uFromString $ databaseName $ fromMaybe curdb mdb)+    (uFromString tb) (Just useOutdated)++extractTerm :: ToExpr e => e -> QL.Term+extractTerm e = fst $ runQueryM (expr e) def++dumpExpr :: ToExpr e => e -> String+dumpExpr = dumpTermPart "" . extractTerm++dumpTermPart :: Data a => String -> a -> String+dumpTermPart p a = case dataTypeName (dataTypeOf a) of+  name | "Database.RethinkDB.Internal" `isPrefixOf` name ->+    showConstr (toConstr a) ++ maybeFields a+       | ".Utf8" `isSuffixOf` name ->+         show (uToString (fromJust $ cast a))+       | ".Double" `isSuffixOf` name ->+           show (fromJust $ cast a :: Double)+       | ".Seq" `isSuffixOf` name -> dumpSeq a +       | otherwise -> dataTypeName (dataTypeOf a) -- showConstr (toConstr a)+  where fieldValues t = gmapQ maybeDump t+        fields t = catMaybes $ zipWith (\x y -> fmap ((x ++ ": ") ++) y)+                   (constrFields (toConstr t)) (fieldValues t)+        maybeFields t = let f = fields t in if null f then ""+                        else " {\n" ++ p ++ concat (intersperse (",\n"++p) f) ++ " }"+        maybeDump :: Data a => a -> Maybe String+        maybeDump t = case showConstr (toConstr t) of+          "Nothing" -> Nothing+          "Just" -> Just $ head (gmapQ (dumpTermPart (p ++ "  ")) t)+          "empty" -> Nothing -- empty Seq+          "ExtField" -> Nothing+          _ -> Just $ dumpTermPart (p ++ "  ") t+        dumpSeq t = let elems :: Data a => a -> [String]+                        elems tt = case showConstr (toConstr tt) of +                          "empty" -> []+                          _ -> gmapQi 0 (dumpTermPart (p ++ "  ")) tt : gmapQi 1 elems tt+          in "[" ++ concat (intersperse ", " $ elems t) ++ "]"
+ Database/RethinkDB/Driver.hs-boot view
@@ -0,0 +1,13 @@+{-# LANGUAGE TypeFamilies, ConstraintKinds, DataKinds #-}+module Database.RethinkDB.Driver where+import Database.RethinkDB.Types+class ToExpr a+class ToValue e+type family ExprType a :: ExprTypeKind+type family ToValueType (t :: ExprTypeKind) :: ValueTypeKind+type HasValueType a v = (ToValue a, ToValueType (ExprType a) ~ v)+type HaveValueType a b v = (HasValueType a v, HasValueType b v)+data Expr (a :: ExprTypeKind)+type NumberExpr = Expr (ValueType NumberType)+type family ExprTypeIsView (expr :: ExprTypeKind) :: Bool+type ExprIsView e = ExprTypeIsView (ExprType e)
+ Database/RethinkDB/Functions.hs view
@@ -0,0 +1,437 @@+{-# LANGUAGE DataKinds, TypeFamilies, ConstraintKinds, FlexibleInstances, +             FlexibleContexts, TypeOperators, ViewPatterns #-}++-- | Functions from the ReQL (RethinkDB Query Language)++module Database.RethinkDB.Functions where++import Database.RethinkDB.Types+import Database.RethinkDB.Driver++import Text.ProtocolBuffers.Basic hiding (Default)+import qualified Database.RethinkDB.Internal.Types as QL+import qualified Database.RethinkDB.Internal.Query_Language.Term as QLTerm+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as QLWriteQuery+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as QLBuiltin+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy as QLOrderBy+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as QLReduction++import qualified Prelude as P+import Prelude (Bool(..), ($), Maybe(..), Int, String, flip, undefined, return, (.), mapM)++import Control.Monad (liftM)+import Data.Maybe+import Data.Functor+import Data.Aeson+import qualified Data.Sequence as Seq++-- * Numbers, Booleans and Comparisons++signum, signum' :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr+signum x = bind x (\n -> if' (n `lt` (0 :: NumberExpr)) (-1 :: Int)+                         (if' (n `lt` (0 :: NumberExpr)) (1 :: Int) (0 :: Int)))+signum' = signum++(+), add, (-), sub, (*), mul, (/), div', mod, mod'+  :: (HaveValueType a b NumberType) => a -> b -> NumberExpr++(+) a b = simpleOp QL.ADD [value a, value b]+(-) a b = simpleOp QL.SUBTRACT [value a, value b]+(*) a b = simpleOp QL.MULTIPLY [value a, value b]+(/) a b = simpleOp QL.DIVIDE [value a, value b]+add = (+)+sub = (-)+mul = (*)+div' = (/)++mod a b = simpleOp QL.MODULO [value a, value b]+mod' = mod++or, or', and, and' :: HaveValueType a b BoolType => a -> b -> BoolExpr+or a b = simpleOp QL.ANY [value a, value b]+and a b = simpleOp QL.ALL [value a, value b]+or' = or+and' = and++(==), (!=), eq, ne :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr+eq a b = comparison QL.EQ [value a, value b]+ne a b = comparison QL.NE [value a, value b]+(==) = eq+(!=) = ne++(>), (>=), (<), (<=), gt, lt, ge, le+  :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr+gt a b = comparison QL.GT [value a, value b]+lt a b = comparison QL.LT [value a, value b]+ge a b = comparison QL.GE [value a, value b]+le a b = comparison QL.LE [value a, value b]+(>) = gt+(>=) = ge+(<) = lt+(<=) = le++not, not' :: HasValueType a BoolType => a -> BoolExpr+not a = simpleOp QL.NOT [value a]+not' = not++-- * Lists and Streams++length, count :: (ToExpr e, Sequence (ExprType e)) => e -> NumberExpr+count e = simpleOp QL.LENGTH [expr e]+length = count++(++), concat :: (HaveValueType a b v, CanConcat v) => a -> b -> Expr (ValueType v)+(++) a b = simpleOp QL.ADD [value a, value b]+concat = (++)++map, map' :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) =>+       m -> e -> Expr (StreamType False (MappingTo m))+map fun a = mkExpr $ do+  mapp <- mapping fun+  rapply [expr a] $ (op QL.MAP) {+    QL.map = Just $ QL.Map mapp }++map' = map++-- | Get all the documents for which the given predicate is true+filter', filter :: (ToMapping m, ToStream e,+                    MappingFrom m `HasToStreamValueOf` e) =>+                   m -> e -> Expr (ExprType e)+filter' fil e = Expr $ do+  mapp <- mapping fil+  (vw, term) <- exprV e+  withView vw $ rapply [return term] $ (op QL.FILTER) {+    QL.filter = Just $ QL.Filter $ mappingToPredicate mapp }++filter = filter'++-- | Get all documents between two primary keys (both keys are inclusive)+between :: (ToJSON a, ToStream e, ObjectType `HasToStreamValueOf` e) =>+           (Maybe a) -> (Maybe a) -> e -> Expr (ExprType e)+between a b e = Expr $ do+  (vw, term) <- exprV e+  withView vw $ rapply [return term] (op QL.RANGE) {+          QL.range = Just $ QL.Range (viewKeyAttr vw)+                     (fmap toJsonTerm a) (fmap toJsonTerm b) }++append :: (HasValueType a ArrayType, HasValueType b x) => a -> b -> ArrayExpr+append a b = simpleOp QL.ARRAYAPPEND [value a, value b]++concatMap, concatMap' ::+  (ToMapping m, (MappingTo m) ~ ArrayType,+   ToStream e, MappingFrom m `HasToStreamValueOf` e) =>+   m -> e -> Expr (StreamType False t)+concatMap fun e = mkExpr $ do+  mapp <- mapping fun+  rapply [stream e] (op QL.CONCATMAP) {+    QL.concat_map = Just $ QL.ConcatMap mapp }++concatMap' = concatMap++innerJoin :: (ToStream a, l `HasToStreamValueOf` a,+              ToStream b, r `HasToStreamValueOf` b) =>+             a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) ->+             Expr (StreamType False ObjectType)+innerJoin self other p =+  flip concatMap self+  (\row -> flip concatMap other+           (\row2 -> if' (p row row2)+                     [obj ["left" := row, "right" := row2]]+                     nil))++outerJoin :: (ToStream a, l `HasToStreamValueOf` a,+              ToStream b, r `HasToStreamValueOf` b) =>+             a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) ->+             Expr (StreamType False ObjectType)+outerJoin self other p =+  flip concatMap' self+  (\row -> bind (flip concatMap' other+                 (\row2 -> if' (p row row2)+                           [obj ["left" := row, "right" := row2]]+                           nil))+           (\matches ->+             if' (count matches `gt` (0 :: Int)) (asArray matches) [obj ["left" := row]]))++asArray :: ToExpr e => e -> ArrayExpr+asArray e = mkExpr $ expr e++eqJoin :: (ToStream a, ObjectType `HasToStreamValueOf` a,+           ToExpr b, ExprType b ~ ExprType Selection) =>+           a -> String -> b -> Expr (StreamType False ObjectType)+eqJoin this k1 other =+  flip concatMap this $ \row ->+    bind (get other (row ! k1)) $ \right ->+      if' (right != ()) [obj ["left" := row, "right" := right]] nil++drop, drop', skip :: (ToStream e, t `HasToStreamValueOf` e,+         ToExpr n, ExprType n ~ ValueType NumberType) =>+        e -> n -> Expr (StreamType (ExprIsView e) t)+drop e n = Expr $ do+  (vw, ex) <- exprV e+  withView vw $ rapply [return ex, expr (), expr n] (op QL.SLICE)+drop' = drop+skip = drop++take, take', limit :: (ToStream e, t `HasToStreamValueOf` e,+         ToExpr n, ExprType n ~ ValueType NumberType) =>+        e -> n -> Expr (StreamType (ExprIsView e) t)+take e n = Expr $ do+  (vw, ex) <- exprV e+  withView vw $ rapply [return ex, expr n, expr ()] (op QL.SLICE)+take' = take+limit  = take++slice :: (ToStream e, t `HasToStreamValueOf` e,+         ToExpr n, ExprType n ~ ValueType NumberType,+         ToExpr m, ExprType m ~ ValueType NumberType) =>+        e -> n -> m -> Expr (StreamType (ExprIsView e) t)+slice e n m = Expr $ do+  (vw, ex) <- exprV e+  withView vw $ rapply [return ex, expr n, expr m] (op QL.SLICE)++(!!), nth :: (ToStream e, t `HasToStreamValueOf` e,+        ToExpr n, ExprType n ~ ValueType NumberType) =>+        e -> n -> ValueExpr t+nth e n = Expr $ withView NoView $ rapply [stream e, expr n] (op QL.NTH)+(!!) = nth++-- | The empty list expression+nil :: ValueExpr ArrayType+nil = toExpr ([] :: [()])++union, union' :: (ToStream a, t `HasToStreamValueOf` a,+           ToStream b, t `HasToStreamValueOf` b) =>+          a -> b -> Expr (StreamType False t)+union a b = simpleOp QL.UNION [stream a, stream b]+union' = union++-- | A fold+-- +-- >>> run h $ reduce [1,2,3] (0 :: Int) (+)+-- 6++fold :: (ToValue z, ToValueType (ExprType z) ~ a,+         ToStream e, b `HasToStreamValueOf` e,+         ToExpr c, ExprIsView c ~ False) =>+        (ValueExpr a -> ValueExpr b -> c) -> z -> e -> Expr (ExprType c)+fold f a e = Expr $ do+  v1 <- newVar+  v2 <- newVar+  aq <- value a+  result <- expr (f (var v1) (var v2))+  withView NoView $ rapply [stream e] (op QL.REDUCE) {+    QL.reduce = Just $ QL.Reduction {+       QL.base = aq,+       QL.var1 = uFromString v1,+       QL.var2 = uFromString v2, +       QLReduction.body = result } }++reduce :: (ToValue z, ToValueType (ExprType z) ~ a,+         ToStream e, b `HasToStreamValueOf` e,+         ToExpr c, ExprIsView c ~ False) =>+        e -> z -> (ValueExpr a -> ValueExpr b -> c) -> Expr (ExprType c)+reduce this base f = fold f base this++distinct :: (ToStream e, v `HasToStreamValueOf` e) =>+            e -> Expr (StreamType False v)+distinct e = simpleOp QL.DISTINCT [stream e]++-- TODO: does not work+groupedMapReduce :: (ToValue group, ToValue value,+                     ToValue acc, ToValueType (ExprType acc) ~ b,+                     ToValue acc', ToValueType (ExprType acc') ~ b,+                     ToStream e, a `HasToStreamValueOf` e) =>+                    (ValueExpr a -> group) ->+                    (ValueExpr a -> value) ->+                    acc ->+                    (ValueExpr b -> ValueExpr v -> acc') ->+                    e -> +                    Expr (StreamType False b)+groupedMapReduce group val base reduction e = Expr $ do+  g <- mapping group+  v <- mapping val+  v1 <- newVar+  v2 <- newVar+  b <- value base+  result <- value (reduction (var v1) (var v2))+  withView NoView $ rapply [stream e] (op QL.GROUPEDMAPREDUCE) {+    QL.grouped_map_reduce = Just $ QL.GroupedMapReduce {+       QL.group_mapping = g,+       QL.value_mapping = v,+       QL.reduction = QL.Reduction {+         QL.base = b, +         QL.var1 = uFromString v1,+         QL.var2 = uFromString v2,+         QLReduction.body = result }} }++-- | Execute a write query for each element of the stream+-- +-- >>> run h $ forEach [1,2,3::Int] (\x -> insert (table "fruits") (obj ["n" := x]))++forEach :: (ToStream a, v `HasToStreamValueOf` a) =>+           a -> (ValueExpr v -> WriteQuery b) -> WriteQuery ()+forEach s mkwq = WriteQuery (do+  arg <- newVar+  let wq = mkwq (var arg)+  qlwq <- writeQueryBuild wq+  as <- stream s+  return $ defaultValue {+    QLWriteQuery.type' = QL.FOREACH,+    QL.for_each = Just $ QL.ForEach as (uFromString arg) (Seq.singleton qlwq) })+  (whenSuccess_ ())++zip, zip' :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>+             e -> Expr (StreamType False ObjectType)+zip = map (\row -> if' (row !? "right")+                   (merge (row ! "left") (row ! "right"))+                   (row ! "left"))+zip' = zip++data Order = Asc  { orderAttr :: String }+           | Desc { orderAttr :: String }++orderAscending :: Order -> Bool+orderAscending Asc  {} = True+orderAscending Desc {} = False++class ToOrder a where toOrder :: a -> Order+instance ToOrder String where toOrder = Asc+instance ToOrder Order where toOrder o = o++orderBy :: (ToOrder o, ToStream e, a `HasToStreamValueOf` e) =>+           [o] -> e -> Expr (StreamType (ExprIsView e) a)+orderBy o e = Expr $ do+  (vw, ex) <- exprV e+  withView vw $ rapply [return ex] (op QL.ORDERBY) {+    QL.order_by = Seq.fromList $ flip P.map o $ \(toOrder -> x) -> QL.OrderBy {+       QLOrderBy.attr = uFromString (orderAttr x), QL.ascending = Just $ orderAscending x }}++groupBy,groupBy' :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>+                    [String] -> MapReduce ObjectType b c d -> e -> Expr (StreamType False d)+groupBy ks (MapReduce m b r f) e = map f (groupedMapReduce (pick ks) m b r e)+groupBy' = groupBy++data MapReduce a b c d = MapReduce (ValueExpr a -> ValueExpr b) (ValueExpr c)+                         (ValueExpr c -> ValueExpr b -> ValueExpr c)+                         (ValueExpr c -> ValueExpr d)++sum, sum' :: String -> MapReduce ObjectType NumberType NumberType NumberType+sum a = MapReduce (! a) 0 (+) P.id+sum' = sum++count' :: MapReduce ObjectType NoneType NumberType NumberType+count' = MapReduce (P.const (toExpr ())) 0 (\x _ -> x + (1 :: Int)) P.id++avg :: String -> MapReduce ObjectType ArrayType ArrayType NumberType+avg k = MapReduce (\x -> toExpr [x ! k :: NumberExpr, 1]) (toExpr [0,0 :: Int])+        (\a o -> toExpr [(a !! (0 :: Int)) + (o !! (0 :: Int)), (a !! (1 :: Int)) + (o !! (1 :: Int)) :: NumberExpr])+        (\a -> ((a !! (0 :: Int)) / (a !! (1 :: Int))))++-- * Accessors++-- | Get the value of the field of an object+-- +-- When GHC thinks the result is ambiguous, it may have to be annotated.+-- +-- >>> run h $ (get (table "tea") "black" ! "water_temperature" :: NumberExpr)+-- 95++(!) :: (ToExpr a, ExprValueType a ~ ObjectType) => a -> String -> ValueExpr t+(!) a b = mkExpr $ rapply [expr a] (op QL.GETATTR) {+  QLBuiltin.attr = Just (uFromString b) }++pick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr+pick ks e = mkExpr $ rapply [value e] (op QL.PICKATTRS) {+  QL.attrs = Seq.fromList $ P.map uFromString ks }++unpick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr+unpick ks e = mkExpr $ rapply [value e] (op QL.WITHOUT) {+  QL.attrs = Seq.fromList $ P.map uFromString ks }++(!?) :: (HasValueType a ObjectType) => a -> String -> BoolExpr +(!?) a b = mkExpr $ rapply [value a] (op QL.HASATTR) {+  QLBuiltin.attr = Just $ uFromString b }++pluck :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>+         [String] -> e -> Expr (StreamType False ObjectType)+pluck ks = map (pick ks)++without :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>+           [String] -> e -> Expr (StreamType False ObjectType)+without ks = map (unpick ks)++merge :: (ToExpr a, ExprType a ~ ValueType ObjectType,+          ToExpr b, ExprType b ~ ValueType ObjectType) =>+         a -> b -> ObjectExpr+merge this other = simpleOp QL.MAPMERGE [expr this, expr other]++-- * Control Structures, Functions and Javascript++-- | A javascript expression+-- +-- It is often necessary to specify the result type:+-- +-- >>> run h $ (js "1 + 2" :: NumberExpr)+-- 3++js :: String -> Expr (ValueType any)+js s = mkExpr $ return defaultValue {+  QLTerm.type' = QL.JAVASCRIPT,+  QLTerm.javascript = Just $ uFromString ("return (" P.++ s P.++ ")") }++bind :: (ToValue e) => e -> (ValueExpr (ToValueType (ExprType e)) -> Expr t) -> Expr t+bind val f = Expr $ do+  arg <- value val+  v <- newVar+  (vw, body) <- exprV (f (var v))+  withView vw $ return defaultValue {+    QLTerm.type' = QL.LET,+    QLTerm.let' = Just $ QL.Let (Seq.singleton $ QL.VarTermTuple (uFromString v) arg)+                  body }++let' :: [Attribute] -> Expr t -> Expr t+let' pairs e = Expr $ do+  varTerms <- mapM (\(k := v) ->+                     (QL.VarTermTuple (uFromString k)) `liftM` value v) pairs+  (vw, body) <- exprV e+  withView vw $ return defaultValue {+    QLTerm.type' = QL.LET,+    QLTerm.let' = Just $ QL.Let (Seq.fromList $ varTerms) body }++var :: ExprIsView (Expr t) ~ False => String -> Expr t+var v = mkExpr $ return defaultValue { +  QLTerm.type' = QL.VAR,+  QLTerm.var = Just $ uFromString v+  }++if' :: (ToValue e, ToValueType (ExprType e) ~ BoolType,+        ToExpr a, ExprTypeNoView (ExprType a) ~ x,+        ToExpr b, ExprTypeNoView (ExprType b) ~ x,+        ExprTypeIsView x ~ False) =>+          e -> a -> b -> Expr x+if' t a b = mkExpr $ do+  tq <- value t+  aq <- expr a+  bq <- expr b+  return defaultValue {+    QLTerm.type' = QL.IF, QL.if_ = Just $ QL.If tq aq bq }++-- | A javascript function+-- +-- >>> let squareRoot = jsfun "Math.sqrt" :: NumberExpr -> NumberExpr+-- >>> run h $ squareRoot 5 :: IO Double+-- 2.23606797749979++jsfun :: ToValue e => String -> e -> Expr (ValueType y)+jsfun f e = mkExpr $ do +  v <- newVar+  expr (let' [v := e] $ js $ f P.++ "(" P.++ v P.++ ")")++error, error' :: (ExprTypeIsView t ~ False) => String -> Expr t+error m = Expr $ withView NoView $ return defaultValue {+  QLTerm.type' = QL.ERROR, QL.error = Just $ uFromString m }+error' = error++class CanConcat (a :: ValueTypeKind)+instance CanConcat StringType+instance CanConcat ArrayType
+ Database/RethinkDB/Functions.hs-boot view
@@ -0,0 +1,9 @@+{-# LANGUAGE ConstraintKinds, DataKinds, TypeFamilies #-}+module Database.RethinkDB.Functions where+import Database.RethinkDB.Types+import {-# SOURCE #-} Database.RethinkDB.Driver+add, sub, mul, div'+  :: (HaveValueType a b NumberType) => a -> b -> NumberExpr+jsfun :: ToValue e => String -> e -> Expr (ValueType y)+var :: ExprIsView (Expr t) ~ False => String -> Expr t+signum' :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr
+ Database/RethinkDB/Internal/Query_Language/Builtin.hs view
@@ -0,0 +1,123 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin (Builtin(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType as Query_Language.Builtin (BuiltinType)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Comparison as Query_Language.Builtin (Comparison)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap as Query_Language.Builtin (ConcatMap)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Filter as Query_Language.Builtin (Filter)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce as Query_Language.Builtin (GroupedMapReduce)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Map as Query_Language.Builtin (Map)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy as Query_Language.Builtin (OrderBy)+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Range as Query_Language.Builtin (Range)+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as Query_Language (Reduction)+ +data Builtin = Builtin{type' :: !Query_Language.Builtin.BuiltinType, attr :: !(P'.Maybe P'.Utf8), attrs :: !(P'.Seq P'.Utf8),+                       comparison :: !(P'.Maybe Query_Language.Builtin.Comparison),+                       filter :: !(P'.Maybe Query_Language.Builtin.Filter), map :: !(P'.Maybe Query_Language.Builtin.Map),+                       concat_map :: !(P'.Maybe Query_Language.Builtin.ConcatMap),+                       order_by :: !(P'.Seq Query_Language.Builtin.OrderBy), reduce :: !(P'.Maybe Query_Language.Reduction),+                       grouped_map_reduce :: !(P'.Maybe Query_Language.Builtin.GroupedMapReduce),+                       range :: !(P'.Maybe Query_Language.Builtin.Range)}+             deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Builtin where+  mergeAppend (Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11) (Builtin y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10 y'11)+   = Builtin (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+      (P'.mergeAppend x'5 y'5)+      (P'.mergeAppend x'6 y'6)+      (P'.mergeAppend x'7 y'7)+      (P'.mergeAppend x'8 y'8)+      (P'.mergeAppend x'9 y'9)+      (P'.mergeAppend x'10 y'10)+      (P'.mergeAppend x'11 y'11)+ +instance P'.Default Builtin where+  defaultValue+   = Builtin P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+ +instance P'.Wire Builtin where+  wireSize ft' self'@(Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size+         = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeRep 1 9 x'3 + P'.wireSizeOpt 1 14 x'4 ++             P'.wireSizeOpt 1 11 x'5+             + P'.wireSizeOpt 1 11 x'6+             + P'.wireSizeOpt 1 11 x'7+             + P'.wireSizeRep 1 11 x'8+             + P'.wireSizeOpt 1 11 x'9+             + P'.wireSizeOpt 1 11 x'10+             + P'.wireSizeOpt 1 11 x'11)+  wirePut ft' self'@(Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutOpt 18 9 x'2+             P'.wirePutRep 26 9 x'3+             P'.wirePutOpt 32 14 x'4+             P'.wirePutOpt 42 11 x'5+             P'.wirePutOpt 50 11 x'6+             P'.wirePutOpt 58 11 x'7+             P'.wirePutRep 66 11 x'8+             P'.wirePutOpt 74 11 x'9+             P'.wirePutOpt 82 11 x'10+             P'.wirePutOpt 90 11 x'11+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{attr = Prelude'.Just new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{attrs = P'.append (attrs old'Self) new'Field}) (P'.wireGet 9)+             32 -> Prelude'.fmap (\ !new'Field -> old'Self{comparison = Prelude'.Just new'Field}) (P'.wireGet 14)+             42 -> Prelude'.fmap (\ !new'Field -> old'Self{filter = P'.mergeAppend (filter old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             50 -> Prelude'.fmap (\ !new'Field -> old'Self{map = P'.mergeAppend (map old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             58 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{concat_map = P'.mergeAppend (concat_map old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             66 -> Prelude'.fmap (\ !new'Field -> old'Self{order_by = P'.append (order_by old'Self) new'Field}) (P'.wireGet 11)+             74 -> Prelude'.fmap (\ !new'Field -> old'Self{reduce = P'.mergeAppend (reduce old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             82 -> Prelude'.fmap+                    (\ !new'Field ->+                      old'Self{grouped_map_reduce = P'.mergeAppend (grouped_map_reduce old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             90 -> Prelude'.fmap (\ !new'Field -> old'Self{range = P'.mergeAppend (range old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Builtin) Builtin where+  getVal m' f' = f' m'+ +instance P'.GPB Builtin+ +instance P'.ReflectDescriptor Builtin where+  getMessageInfo _+   = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 32, 42, 50, 58, 66, 74, 82, 90])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Builtin\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.BuiltinType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"BuiltinType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.attr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"attr\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.attrs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"attrs\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.comparison\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"comparison\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 32}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Comparison\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Comparison\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.filter\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"filter\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Filter\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Filter\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.map\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"map\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Map\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Map\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.concat_map\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"concat_map\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 58}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.ConcatMap\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"ConcatMap\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.order_by\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"order_by\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.OrderBy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"OrderBy\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.reduce\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"reduce\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.grouped_map_reduce\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"grouped_map_reduce\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 82}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.GroupedMapReduce\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"GroupedMapReduce\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.range\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"range\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 90}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Range\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Range\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs view
@@ -0,0 +1,231 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType (BuiltinType(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data BuiltinType = NOT+                 | GETATTR+                 | IMPLICIT_GETATTR+                 | HASATTR+                 | IMPLICIT_HASATTR+                 | PICKATTRS+                 | IMPLICIT_PICKATTRS+                 | MAPMERGE+                 | ARRAYAPPEND+                 | SLICE+                 | ADD+                 | SUBTRACT+                 | MULTIPLY+                 | DIVIDE+                 | MODULO+                 | COMPARE+                 | FILTER+                 | MAP+                 | CONCATMAP+                 | ORDERBY+                 | DISTINCT+                 | LENGTH+                 | UNION+                 | NTH+                 | STREAMTOARRAY+                 | ARRAYTOSTREAM+                 | REDUCE+                 | GROUPEDMAPREDUCE+                 | ANY+                 | ALL+                 | RANGE+                 | IMPLICIT_WITHOUT+                 | WITHOUT+                 deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable BuiltinType+ +instance Prelude'.Bounded BuiltinType where+  minBound = NOT+  maxBound = WITHOUT+ +instance P'.Default BuiltinType where+  defaultValue = NOT+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe BuiltinType+toMaybe'Enum 1 = Prelude'.Just NOT+toMaybe'Enum 2 = Prelude'.Just GETATTR+toMaybe'Enum 3 = Prelude'.Just IMPLICIT_GETATTR+toMaybe'Enum 4 = Prelude'.Just HASATTR+toMaybe'Enum 5 = Prelude'.Just IMPLICIT_HASATTR+toMaybe'Enum 6 = Prelude'.Just PICKATTRS+toMaybe'Enum 7 = Prelude'.Just IMPLICIT_PICKATTRS+toMaybe'Enum 8 = Prelude'.Just MAPMERGE+toMaybe'Enum 9 = Prelude'.Just ARRAYAPPEND+toMaybe'Enum 11 = Prelude'.Just SLICE+toMaybe'Enum 14 = Prelude'.Just ADD+toMaybe'Enum 15 = Prelude'.Just SUBTRACT+toMaybe'Enum 16 = Prelude'.Just MULTIPLY+toMaybe'Enum 17 = Prelude'.Just DIVIDE+toMaybe'Enum 18 = Prelude'.Just MODULO+toMaybe'Enum 19 = Prelude'.Just COMPARE+toMaybe'Enum 20 = Prelude'.Just FILTER+toMaybe'Enum 21 = Prelude'.Just MAP+toMaybe'Enum 22 = Prelude'.Just CONCATMAP+toMaybe'Enum 23 = Prelude'.Just ORDERBY+toMaybe'Enum 24 = Prelude'.Just DISTINCT+toMaybe'Enum 26 = Prelude'.Just LENGTH+toMaybe'Enum 27 = Prelude'.Just UNION+toMaybe'Enum 28 = Prelude'.Just NTH+toMaybe'Enum 29 = Prelude'.Just STREAMTOARRAY+toMaybe'Enum 30 = Prelude'.Just ARRAYTOSTREAM+toMaybe'Enum 31 = Prelude'.Just REDUCE+toMaybe'Enum 32 = Prelude'.Just GROUPEDMAPREDUCE+toMaybe'Enum 35 = Prelude'.Just ANY+toMaybe'Enum 36 = Prelude'.Just ALL+toMaybe'Enum 37 = Prelude'.Just RANGE+toMaybe'Enum 38 = Prelude'.Just IMPLICIT_WITHOUT+toMaybe'Enum 39 = Prelude'.Just WITHOUT+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum BuiltinType where+  fromEnum NOT = 1+  fromEnum GETATTR = 2+  fromEnum IMPLICIT_GETATTR = 3+  fromEnum HASATTR = 4+  fromEnum IMPLICIT_HASATTR = 5+  fromEnum PICKATTRS = 6+  fromEnum IMPLICIT_PICKATTRS = 7+  fromEnum MAPMERGE = 8+  fromEnum ARRAYAPPEND = 9+  fromEnum SLICE = 11+  fromEnum ADD = 14+  fromEnum SUBTRACT = 15+  fromEnum MULTIPLY = 16+  fromEnum DIVIDE = 17+  fromEnum MODULO = 18+  fromEnum COMPARE = 19+  fromEnum FILTER = 20+  fromEnum MAP = 21+  fromEnum CONCATMAP = 22+  fromEnum ORDERBY = 23+  fromEnum DISTINCT = 24+  fromEnum LENGTH = 26+  fromEnum UNION = 27+  fromEnum NTH = 28+  fromEnum STREAMTOARRAY = 29+  fromEnum ARRAYTOSTREAM = 30+  fromEnum REDUCE = 31+  fromEnum GROUPEDMAPREDUCE = 32+  fromEnum ANY = 35+  fromEnum ALL = 36+  fromEnum RANGE = 37+  fromEnum IMPLICIT_WITHOUT = 38+  fromEnum WITHOUT = 39+  toEnum+   = P'.fromMaybe+      (Prelude'.error+        "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType")+      . toMaybe'Enum+  succ NOT = GETATTR+  succ GETATTR = IMPLICIT_GETATTR+  succ IMPLICIT_GETATTR = HASATTR+  succ HASATTR = IMPLICIT_HASATTR+  succ IMPLICIT_HASATTR = PICKATTRS+  succ PICKATTRS = IMPLICIT_PICKATTRS+  succ IMPLICIT_PICKATTRS = MAPMERGE+  succ MAPMERGE = ARRAYAPPEND+  succ ARRAYAPPEND = SLICE+  succ SLICE = ADD+  succ ADD = SUBTRACT+  succ SUBTRACT = MULTIPLY+  succ MULTIPLY = DIVIDE+  succ DIVIDE = MODULO+  succ MODULO = COMPARE+  succ COMPARE = FILTER+  succ FILTER = MAP+  succ MAP = CONCATMAP+  succ CONCATMAP = ORDERBY+  succ ORDERBY = DISTINCT+  succ DISTINCT = LENGTH+  succ LENGTH = UNION+  succ UNION = NTH+  succ NTH = STREAMTOARRAY+  succ STREAMTOARRAY = ARRAYTOSTREAM+  succ ARRAYTOSTREAM = REDUCE+  succ REDUCE = GROUPEDMAPREDUCE+  succ GROUPEDMAPREDUCE = ANY+  succ ANY = ALL+  succ ALL = RANGE+  succ RANGE = IMPLICIT_WITHOUT+  succ IMPLICIT_WITHOUT = WITHOUT+  succ _+   = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType"+  pred GETATTR = NOT+  pred IMPLICIT_GETATTR = GETATTR+  pred HASATTR = IMPLICIT_GETATTR+  pred IMPLICIT_HASATTR = HASATTR+  pred PICKATTRS = IMPLICIT_HASATTR+  pred IMPLICIT_PICKATTRS = PICKATTRS+  pred MAPMERGE = IMPLICIT_PICKATTRS+  pred ARRAYAPPEND = MAPMERGE+  pred SLICE = ARRAYAPPEND+  pred ADD = SLICE+  pred SUBTRACT = ADD+  pred MULTIPLY = SUBTRACT+  pred DIVIDE = MULTIPLY+  pred MODULO = DIVIDE+  pred COMPARE = MODULO+  pred FILTER = COMPARE+  pred MAP = FILTER+  pred CONCATMAP = MAP+  pred ORDERBY = CONCATMAP+  pred DISTINCT = ORDERBY+  pred LENGTH = DISTINCT+  pred UNION = LENGTH+  pred NTH = UNION+  pred STREAMTOARRAY = NTH+  pred ARRAYTOSTREAM = STREAMTOARRAY+  pred REDUCE = ARRAYTOSTREAM+  pred GROUPEDMAPREDUCE = REDUCE+  pred ANY = GROUPEDMAPREDUCE+  pred ALL = ANY+  pred RANGE = ALL+  pred IMPLICIT_WITHOUT = RANGE+  pred WITHOUT = IMPLICIT_WITHOUT+  pred _+   = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType"+ +instance P'.Wire BuiltinType where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB BuiltinType+ +instance P'.MessageAPI msg' (msg' -> BuiltinType) BuiltinType where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum BuiltinType where+  reflectEnum+   = [(1, "NOT", NOT), (2, "GETATTR", GETATTR), (3, "IMPLICIT_GETATTR", IMPLICIT_GETATTR), (4, "HASATTR", HASATTR),+      (5, "IMPLICIT_HASATTR", IMPLICIT_HASATTR), (6, "PICKATTRS", PICKATTRS), (7, "IMPLICIT_PICKATTRS", IMPLICIT_PICKATTRS),+      (8, "MAPMERGE", MAPMERGE), (9, "ARRAYAPPEND", ARRAYAPPEND), (11, "SLICE", SLICE), (14, "ADD", ADD),+      (15, "SUBTRACT", SUBTRACT), (16, "MULTIPLY", MULTIPLY), (17, "DIVIDE", DIVIDE), (18, "MODULO", MODULO),+      (19, "COMPARE", COMPARE), (20, "FILTER", FILTER), (21, "MAP", MAP), (22, "CONCATMAP", CONCATMAP), (23, "ORDERBY", ORDERBY),+      (24, "DISTINCT", DISTINCT), (26, "LENGTH", LENGTH), (27, "UNION", UNION), (28, "NTH", NTH),+      (29, "STREAMTOARRAY", STREAMTOARRAY), (30, "ARRAYTOSTREAM", ARRAYTOSTREAM), (31, "REDUCE", REDUCE),+      (32, "GROUPEDMAPREDUCE", GROUPEDMAPREDUCE), (35, "ANY", ANY), (36, "ALL", ALL), (37, "RANGE", RANGE),+      (38, "IMPLICIT_WITHOUT", IMPLICIT_WITHOUT), (39, "WITHOUT", WITHOUT)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.Builtin.BuiltinType") ["Database", "RethinkDB", "Internal"]+        ["Query_Language", "Builtin"]+        "BuiltinType")+      ["Database", "RethinkDB", "Internal", "Query_Language", "Builtin", "BuiltinType.hs"]+      [(1, "NOT"), (2, "GETATTR"), (3, "IMPLICIT_GETATTR"), (4, "HASATTR"), (5, "IMPLICIT_HASATTR"), (6, "PICKATTRS"),+       (7, "IMPLICIT_PICKATTRS"), (8, "MAPMERGE"), (9, "ARRAYAPPEND"), (11, "SLICE"), (14, "ADD"), (15, "SUBTRACT"),+       (16, "MULTIPLY"), (17, "DIVIDE"), (18, "MODULO"), (19, "COMPARE"), (20, "FILTER"), (21, "MAP"), (22, "CONCATMAP"),+       (23, "ORDERBY"), (24, "DISTINCT"), (26, "LENGTH"), (27, "UNION"), (28, "NTH"), (29, "STREAMTOARRAY"), (30, "ARRAYTOSTREAM"),+       (31, "REDUCE"), (32, "GROUPEDMAPREDUCE"), (35, "ANY"), (36, "ALL"), (37, "RANGE"), (38, "IMPLICIT_WITHOUT"), (39, "WITHOUT")]
+ Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs view
@@ -0,0 +1,82 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.Comparison (Comparison(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data Comparison = EQ+                | NE+                | LT+                | LE+                | GT+                | GE+                deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Comparison+ +instance Prelude'.Bounded Comparison where+  minBound = EQ+  maxBound = GE+ +instance P'.Default Comparison where+  defaultValue = EQ+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe Comparison+toMaybe'Enum 1 = Prelude'.Just EQ+toMaybe'Enum 2 = Prelude'.Just NE+toMaybe'Enum 3 = Prelude'.Just LT+toMaybe'Enum 4 = Prelude'.Just LE+toMaybe'Enum 5 = Prelude'.Just GT+toMaybe'Enum 6 = Prelude'.Just GE+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum Comparison where+  fromEnum EQ = 1+  fromEnum NE = 2+  fromEnum LT = 3+  fromEnum LE = 4+  fromEnum GT = 5+  fromEnum GE = 6+  toEnum+   = P'.fromMaybe+      (Prelude'.error+        "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison")+      . toMaybe'Enum+  succ EQ = NE+  succ NE = LT+  succ LT = LE+  succ LE = GT+  succ GT = GE+  succ _+   = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison"+  pred NE = EQ+  pred LT = NE+  pred LE = LT+  pred GT = LE+  pred GE = GT+  pred _+   = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison"+ +instance P'.Wire Comparison where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB Comparison+ +instance P'.MessageAPI msg' (msg' -> Comparison) Comparison where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum Comparison where+  reflectEnum = [(1, "EQ", EQ), (2, "NE", NE), (3, "LT", LT), (4, "LE", LE), (5, "GT", GT), (6, "GE", GE)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.Builtin.Comparison") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Builtin"]+        "Comparison")+      ["Database", "RethinkDB", "Internal", "Query_Language", "Builtin", "Comparison.hs"]+      [(1, "EQ"), (2, "NE"), (3, "LT"), (4, "LE"), (5, "GT"), (6, "GE")]
+ Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs view
@@ -0,0 +1,58 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap (ConcatMap(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+ +data ConcatMap = ConcatMap{mapping :: !Query_Language.Mapping}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable ConcatMap where+  mergeAppend (ConcatMap x'1) (ConcatMap y'1) = ConcatMap (P'.mergeAppend x'1 y'1)+ +instance P'.Default ConcatMap where+  defaultValue = ConcatMap P'.defaultValue+ +instance P'.Wire ConcatMap where+  wireSize ft' self'@(ConcatMap x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1)+  wirePut ft' self'@(ConcatMap x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> ConcatMap) ConcatMap where+  getVal m' f' = f' m'+ +instance P'.GPB ConcatMap+ +instance P'.ReflectDescriptor ConcatMap where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.ConcatMap\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"ConcatMap\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"ConcatMap.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.ConcatMap.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"ConcatMap\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs view
@@ -0,0 +1,59 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.Filter (Filter(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Predicate as Query_Language (Predicate)+ +data Filter = Filter{predicate :: !Query_Language.Predicate}+            deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Filter where+  mergeAppend (Filter x'1) (Filter y'1) = Filter (P'.mergeAppend x'1 y'1)+ +instance P'.Default Filter where+  defaultValue = Filter P'.defaultValue+ +instance P'.Wire Filter where+  wireSize ft' self'@(Filter x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1)+  wirePut ft' self'@(Filter x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{predicate = P'.mergeAppend (predicate old'Self) (new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Filter) Filter where+  getVal m' f' = f' m'+ +instance P'.GPB Filter+ +instance P'.ReflectDescriptor Filter where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Filter\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Filter\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Filter.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Filter.predicate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Filter\"], baseName' = FName \"predicate\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Predicate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Predicate\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs view
@@ -0,0 +1,68 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce (GroupedMapReduce(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as Query_Language (Reduction)+ +data GroupedMapReduce = GroupedMapReduce{group_mapping :: !Query_Language.Mapping, value_mapping :: !Query_Language.Mapping,+                                         reduction :: !Query_Language.Reduction}+                      deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable GroupedMapReduce where+  mergeAppend (GroupedMapReduce x'1 x'2 x'3) (GroupedMapReduce y'1 y'2 y'3)+   = GroupedMapReduce (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default GroupedMapReduce where+  defaultValue = GroupedMapReduce P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire GroupedMapReduce where+  wireSize ft' self'@(GroupedMapReduce x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeReq 1 11 x'3)+  wirePut ft' self'@(GroupedMapReduce x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 11 x'2+             P'.wirePutReq 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{group_mapping = P'.mergeAppend (group_mapping old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{value_mapping = P'.mergeAppend (value_mapping old'Self) (new'Field)})+                    (P'.wireGet 11)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{reduction = P'.mergeAppend (reduction old'Self) (new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> GroupedMapReduce) GroupedMapReduce where+  getVal m' f' = f' m'+ +instance P'.GPB GroupedMapReduce+ +instance P'.ReflectDescriptor GroupedMapReduce where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.GroupedMapReduce\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"GroupedMapReduce\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"GroupedMapReduce.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.group_mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"group_mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.value_mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"value_mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.reduction\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"reduction\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs view
@@ -0,0 +1,58 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.Map (Map(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+ +data Map = Map{mapping :: !Query_Language.Mapping}+         deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Map where+  mergeAppend (Map x'1) (Map y'1) = Map (P'.mergeAppend x'1 y'1)+ +instance P'.Default Map where+  defaultValue = Map P'.defaultValue+ +instance P'.Wire Map where+  wireSize ft' self'@(Map x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1)+  wirePut ft' self'@(Map x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Map) Map where+  getVal m' f' = f' m'+ +instance P'.GPB Map+ +instance P'.ReflectDescriptor Map where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Map\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Map\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Map.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Map.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Map\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs view
@@ -0,0 +1,59 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy (OrderBy(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data OrderBy = OrderBy{attr :: !P'.Utf8, ascending :: !(P'.Maybe P'.Bool)}+             deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable OrderBy where+  mergeAppend (OrderBy x'1 x'2) (OrderBy y'1 y'2) = OrderBy (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default OrderBy where+  defaultValue = OrderBy P'.defaultValue (Prelude'.Just Prelude'.True)+ +instance P'.Wire OrderBy where+  wireSize ft' self'@(OrderBy x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeOpt 1 8 x'2)+  wirePut ft' self'@(OrderBy x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutOpt 16 8 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{attr = new'Field}) (P'.wireGet 9)+             16 -> Prelude'.fmap (\ !new'Field -> old'Self{ascending = Prelude'.Just new'Field}) (P'.wireGet 8)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> OrderBy) OrderBy where+  getVal m' f' = f' m'+ +instance P'.GPB OrderBy+ +instance P'.ReflectDescriptor OrderBy where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 16])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.OrderBy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"OrderBy\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"OrderBy.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.OrderBy.attr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"OrderBy\"], baseName' = FName \"attr\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.OrderBy.ascending\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"OrderBy\"], baseName' = FName \"ascending\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"true\", hsDefault = Just (HsDef'Bool True)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs view
@@ -0,0 +1,68 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Builtin.Range (Range(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Range = Range{attrname :: !P'.Utf8, lowerbound :: !(P'.Maybe Query_Language.Term),+                   upperbound :: !(P'.Maybe Query_Language.Term)}+           deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Range where+  mergeAppend (Range x'1 x'2 x'3) (Range y'1 y'2 y'3)+   = Range (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default Range where+  defaultValue = Range P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire Range where+  wireSize ft' self'@(Range x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeOpt 1 11 x'2 + P'.wireSizeOpt 1 11 x'3)+  wirePut ft' self'@(Range x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutOpt 18 11 x'2+             P'.wirePutOpt 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)+             18 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{lowerbound = P'.mergeAppend (lowerbound old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             26 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{upperbound = P'.mergeAppend (upperbound old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Range) Range where+  getVal m' f' = f' m'+ +instance P'.GPB Range+ +instance P'.ReflectDescriptor Range where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Range\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Range\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Range.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.lowerbound\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"lowerbound\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.upperbound\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"upperbound\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Mapping.hs view
@@ -0,0 +1,69 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Mapping (Mapping(..)) where+import Prelude ((+), (/), (==), (<=), (&&))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Mapping = Mapping{arg :: !P'.Utf8, body :: !Query_Language.Term, ext'field :: !P'.ExtField}+             deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.ExtendMessage Mapping where+  getExtField = ext'field+  putExtField e'f msg = msg{ext'field = e'f}+  validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)+ +instance P'.Mergeable Mapping where+  mergeAppend (Mapping x'1 x'2 x'3) (Mapping y'1 y'2 y'3)+   = Mapping (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default Mapping where+  defaultValue = Mapping P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire Mapping where+  wireSize ft' self'@(Mapping x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeExtField x'3)+  wirePut ft' self'@(Mapping x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutReq 18 11 x'2+             P'.wirePutExtField x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{arg = new'Field}) (P'.wireGet 9)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in+                   if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then+                    P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Mapping) Mapping where+  getVal m' f' = f' m'+ +instance P'.GPB Mapping+ +instance P'.ReflectDescriptor Mapping where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Mapping.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Mapping.arg\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Mapping\"], baseName' = FName \"arg\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Mapping.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Mapping\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/MetaQuery.hs view
@@ -0,0 +1,73 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.MetaQuery (MetaQuery(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable as Query_Language.MetaQuery (CreateTable)+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType as Query_Language.MetaQuery (MetaQueryType)+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+ +data MetaQuery = MetaQuery{type' :: !Query_Language.MetaQuery.MetaQueryType, db_name :: !(P'.Maybe P'.Utf8),+                           create_table :: !(P'.Maybe Query_Language.MetaQuery.CreateTable),+                           drop_table :: !(P'.Maybe Query_Language.TableRef)}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable MetaQuery where+  mergeAppend (MetaQuery x'1 x'2 x'3 x'4) (MetaQuery y'1 y'2 y'3 y'4)+   = MetaQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default MetaQuery where+  defaultValue = MetaQuery P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire MetaQuery where+  wireSize ft' self'@(MetaQuery x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4)+  wirePut ft' self'@(MetaQuery x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutOpt 18 9 x'2+             P'.wirePutOpt 26 11 x'3+             P'.wirePutOpt 34 11 x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{db_name = Prelude'.Just new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{create_table = P'.mergeAppend (create_table old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             34 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{drop_table = P'.mergeAppend (drop_table old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> MetaQuery) MetaQuery where+  getVal m' f' = f' m'+ +instance P'.GPB MetaQuery+ +instance P'.ReflectDescriptor MetaQuery where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 34])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.MetaQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"MetaQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"MetaQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery.MetaQueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"MetaQueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.db_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"db_name\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.create_table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"create_table\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery.CreateTable\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"CreateTable\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.drop_table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"drop_table\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs view
@@ -0,0 +1,67 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable (CreateTable(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+ +data CreateTable = CreateTable{datacenter :: !(P'.Maybe P'.Utf8), table_ref :: !Query_Language.TableRef,+                               primary_key :: !(P'.Maybe P'.Utf8), cache_size :: !(P'.Maybe P'.Int64)}+                 deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable CreateTable where+  mergeAppend (CreateTable x'1 x'2 x'3 x'4) (CreateTable y'1 y'2 y'3 y'4)+   = CreateTable (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default CreateTable where+  defaultValue = CreateTable P'.defaultValue P'.defaultValue (Prelude'.Just (P'.Utf8 (P'.pack "id"))) (Prelude'.Just 1073741824)+ +instance P'.Wire CreateTable where+  wireSize ft' self'@(CreateTable x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeOpt 1 9 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeOpt 1 9 x'3 + P'.wireSizeOpt 1 3 x'4)+  wirePut ft' self'@(CreateTable x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutOpt 10 9 x'1+             P'.wirePutReq 26 11 x'2+             P'.wirePutOpt 34 9 x'3+             P'.wirePutOpt 40 3 x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{datacenter = Prelude'.Just new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{primary_key = Prelude'.Just new'Field}) (P'.wireGet 9)+             40 -> Prelude'.fmap (\ !new'Field -> old'Self{cache_size = Prelude'.Just new'Field}) (P'.wireGet 3)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> CreateTable) CreateTable where+  getVal m' f' = f' m'+ +instance P'.GPB CreateTable+ +instance P'.ReflectDescriptor CreateTable where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [26]) (P'.fromDistinctAscList [10, 26, 34, 40])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.MetaQuery.CreateTable\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"CreateTable\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"MetaQuery\",\"CreateTable.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.datacenter\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"datacenter\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.primary_key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"primary_key\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Just \"id\", hsDefault = Just (HsDef'ByteString \"id\")},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.cache_size\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"cache_size\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 40}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Just \"1073741824\", hsDefault = Just (HsDef'Integer 1073741824)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs view
@@ -0,0 +1,87 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType (MetaQueryType(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data MetaQueryType = CREATE_DB+                   | DROP_DB+                   | LIST_DBS+                   | CREATE_TABLE+                   | DROP_TABLE+                   | LIST_TABLES+                   deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable MetaQueryType+ +instance Prelude'.Bounded MetaQueryType where+  minBound = CREATE_DB+  maxBound = LIST_TABLES+ +instance P'.Default MetaQueryType where+  defaultValue = CREATE_DB+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe MetaQueryType+toMaybe'Enum 1 = Prelude'.Just CREATE_DB+toMaybe'Enum 2 = Prelude'.Just DROP_DB+toMaybe'Enum 3 = Prelude'.Just LIST_DBS+toMaybe'Enum 4 = Prelude'.Just CREATE_TABLE+toMaybe'Enum 5 = Prelude'.Just DROP_TABLE+toMaybe'Enum 6 = Prelude'.Just LIST_TABLES+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum MetaQueryType where+  fromEnum CREATE_DB = 1+  fromEnum DROP_DB = 2+  fromEnum LIST_DBS = 3+  fromEnum CREATE_TABLE = 4+  fromEnum DROP_TABLE = 5+  fromEnum LIST_TABLES = 6+  toEnum+   = P'.fromMaybe+      (Prelude'.error+        "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType")+      . toMaybe'Enum+  succ CREATE_DB = DROP_DB+  succ DROP_DB = LIST_DBS+  succ LIST_DBS = CREATE_TABLE+  succ CREATE_TABLE = DROP_TABLE+  succ DROP_TABLE = LIST_TABLES+  succ _+   = Prelude'.error+      "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType"+  pred DROP_DB = CREATE_DB+  pred LIST_DBS = DROP_DB+  pred CREATE_TABLE = LIST_DBS+  pred DROP_TABLE = CREATE_TABLE+  pred LIST_TABLES = DROP_TABLE+  pred _+   = Prelude'.error+      "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType"+ +instance P'.Wire MetaQueryType where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB MetaQueryType+ +instance P'.MessageAPI msg' (msg' -> MetaQueryType) MetaQueryType where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum MetaQueryType where+  reflectEnum+   = [(1, "CREATE_DB", CREATE_DB), (2, "DROP_DB", DROP_DB), (3, "LIST_DBS", LIST_DBS), (4, "CREATE_TABLE", CREATE_TABLE),+      (5, "DROP_TABLE", DROP_TABLE), (6, "LIST_TABLES", LIST_TABLES)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.MetaQuery.MetaQueryType") ["Database", "RethinkDB", "Internal"]+        ["Query_Language", "MetaQuery"]+        "MetaQueryType")+      ["Database", "RethinkDB", "Internal", "Query_Language", "MetaQuery", "MetaQueryType.hs"]+      [(1, "CREATE_DB"), (2, "DROP_DB"), (3, "LIST_DBS"), (4, "CREATE_TABLE"), (5, "DROP_TABLE"), (6, "LIST_TABLES")]
+ Database/RethinkDB/Internal/Query_Language/Predicate.hs view
@@ -0,0 +1,60 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Predicate (Predicate(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Predicate = Predicate{arg :: !P'.Utf8, body :: !Query_Language.Term}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Predicate where+  mergeAppend (Predicate x'1 x'2) (Predicate y'1 y'2) = Predicate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default Predicate where+  defaultValue = Predicate P'.defaultValue P'.defaultValue+ +instance P'.Wire Predicate where+  wireSize ft' self'@(Predicate x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2)+  wirePut ft' self'@(Predicate x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutReq 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{arg = new'Field}) (P'.wireGet 9)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Predicate) Predicate where+  getVal m' f' = f' m'+ +instance P'.GPB Predicate+ +instance P'.ReflectDescriptor Predicate where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Predicate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Predicate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Predicate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Predicate.arg\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Predicate\"], baseName' = FName \"arg\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Predicate.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Predicate\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Query.hs view
@@ -0,0 +1,80 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Query (Query(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery as Query_Language (MetaQuery)+import qualified Database.RethinkDB.Internal.Query_Language.Query.QueryType as Query_Language.Query (QueryType)+import qualified Database.RethinkDB.Internal.Query_Language.ReadQuery as Query_Language (ReadQuery)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as Query_Language (WriteQuery)+ +data Query = Query{type' :: !Query_Language.Query.QueryType, token :: !P'.Int64, read_query :: !(P'.Maybe Query_Language.ReadQuery),+                   write_query :: !(P'.Maybe Query_Language.WriteQuery), meta_query :: !(P'.Maybe Query_Language.MetaQuery)}+           deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Query where+  mergeAppend (Query x'1 x'2 x'3 x'4 x'5) (Query y'1 y'2 y'3 y'4 y'5)+   = Query (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+      (P'.mergeAppend x'5 y'5)+ +instance P'.Default Query where+  defaultValue = Query P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire Query where+  wireSize ft' self'@(Query x'1 x'2 x'3 x'4 x'5)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size+         = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeReq 1 3 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 ++             P'.wireSizeOpt 1 11 x'5)+  wirePut ft' self'@(Query x'1 x'2 x'3 x'4 x'5)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutReq 16 3 x'2+             P'.wirePutOpt 26 11 x'3+             P'.wirePutOpt 34 11 x'4+             P'.wirePutOpt 42 11 x'5+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)+             16 -> Prelude'.fmap (\ !new'Field -> old'Self{token = new'Field}) (P'.wireGet 3)+             26 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{read_query = P'.mergeAppend (read_query old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             34 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{write_query = P'.mergeAppend (write_query old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             42 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{meta_query = P'.mergeAppend (meta_query old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Query) Query where+  getVal m' f' = f' m'+ +instance P'.GPB Query+ +instance P'.ReflectDescriptor Query where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8, 16]) (P'.fromDistinctAscList [8, 16, 26, 34, 42])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Query\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Query\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Query.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Query.QueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Query\"], baseName = MName \"QueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"token\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.read_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"read_query\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.ReadQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"ReadQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.write_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"write_query\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.meta_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"meta_query\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"MetaQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs view
@@ -0,0 +1,74 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Query.QueryType (QueryType(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data QueryType = READ+               | WRITE+               | CONTINUE+               | STOP+               | META+               deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable QueryType+ +instance Prelude'.Bounded QueryType where+  minBound = READ+  maxBound = META+ +instance P'.Default QueryType where+  defaultValue = READ+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe QueryType+toMaybe'Enum 1 = Prelude'.Just READ+toMaybe'Enum 2 = Prelude'.Just WRITE+toMaybe'Enum 3 = Prelude'.Just CONTINUE+toMaybe'Enum 4 = Prelude'.Just STOP+toMaybe'Enum 5 = Prelude'.Just META+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum QueryType where+  fromEnum READ = 1+  fromEnum WRITE = 2+  fromEnum CONTINUE = 3+  fromEnum STOP = 4+  fromEnum META = 5+  toEnum+   = P'.fromMaybe+      (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType")+      . toMaybe'Enum+  succ READ = WRITE+  succ WRITE = CONTINUE+  succ CONTINUE = STOP+  succ STOP = META+  succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType"+  pred WRITE = READ+  pred CONTINUE = WRITE+  pred STOP = CONTINUE+  pred META = STOP+  pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType"+ +instance P'.Wire QueryType where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB QueryType+ +instance P'.MessageAPI msg' (msg' -> QueryType) QueryType where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum QueryType where+  reflectEnum = [(1, "READ", READ), (2, "WRITE", WRITE), (3, "CONTINUE", CONTINUE), (4, "STOP", STOP), (5, "META", META)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.Query.QueryType") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Query"]+        "QueryType")+      ["Database", "RethinkDB", "Internal", "Query_Language", "Query", "QueryType.hs"]+      [(1, "READ"), (2, "WRITE"), (3, "CONTINUE"), (4, "STOP"), (5, "META")]
+ Database/RethinkDB/Internal/Query_Language/ReadQuery.hs view
@@ -0,0 +1,72 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.ReadQuery (ReadQuery(..)) where+import Prelude ((+), (/), (==), (<=), (&&))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data ReadQuery = ReadQuery{term :: !Query_Language.Term, max_chunk_size :: !(P'.Maybe P'.Int64), max_age :: !(P'.Maybe P'.Int64),+                           ext'field :: !P'.ExtField}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.ExtendMessage ReadQuery where+  getExtField = ext'field+  putExtField e'f msg = msg{ext'field = e'f}+  validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)+ +instance P'.Mergeable ReadQuery where+  mergeAppend (ReadQuery x'1 x'2 x'3 x'4) (ReadQuery y'1 y'2 y'3 y'4)+   = ReadQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default ReadQuery where+  defaultValue = ReadQuery P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire ReadQuery where+  wireSize ft' self'@(ReadQuery x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeOpt 1 3 x'2 + P'.wireSizeOpt 1 3 x'3 + P'.wireSizeExtField x'4)+  wirePut ft' self'@(ReadQuery x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutOpt 16 3 x'2+             P'.wirePutOpt 24 3 x'3+             P'.wirePutExtField x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{term = P'.mergeAppend (term old'Self) (new'Field)}) (P'.wireGet 11)+             16 -> Prelude'.fmap (\ !new'Field -> old'Self{max_chunk_size = Prelude'.Just new'Field}) (P'.wireGet 3)+             24 -> Prelude'.fmap (\ !new'Field -> old'Self{max_age = Prelude'.Just new'Field}) (P'.wireGet 3)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in+                   if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then+                    P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> ReadQuery) ReadQuery where+  getVal m' f' = f' m'+ +instance P'.GPB ReadQuery+ +instance P'.ReflectDescriptor ReadQuery where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 16, 24])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.ReadQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"ReadQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"ReadQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.term\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"term\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.max_chunk_size\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"max_chunk_size\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.max_age\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"max_age\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Reduction.hs view
@@ -0,0 +1,65 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Reduction (Reduction(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Reduction = Reduction{base :: !Query_Language.Term, var1 :: !P'.Utf8, var2 :: !P'.Utf8, body :: !Query_Language.Term}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Reduction where+  mergeAppend (Reduction x'1 x'2 x'3 x'4) (Reduction y'1 y'2 y'3 y'4)+   = Reduction (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default Reduction where+  defaultValue = Reduction P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire Reduction where+  wireSize ft' self'@(Reduction x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 9 x'3 + P'.wireSizeReq 1 11 x'4)+  wirePut ft' self'@(Reduction x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutReq 26 9 x'3+             P'.wirePutReq 34 11 x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{base = P'.mergeAppend (base old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{var1 = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{var2 = new'Field}) (P'.wireGet 9)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Reduction) Reduction where+  getVal m' f' = f' m'+ +instance P'.GPB Reduction+ +instance P'.ReflectDescriptor Reduction where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Reduction.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.base\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"base\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.var1\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"var1\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.var2\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"var2\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Response.hs view
@@ -0,0 +1,74 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Response (Response(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Response.Backtrace as Query_Language.Response (Backtrace)+import qualified Database.RethinkDB.Internal.Query_Language.Response.StatusCode as Query_Language.Response (StatusCode)+ +data Response = Response{status_code :: !Query_Language.Response.StatusCode, token :: !P'.Int64, response :: !(P'.Seq P'.Utf8),+                         error_message :: !(P'.Maybe P'.Utf8), backtrace :: !(P'.Maybe Query_Language.Response.Backtrace)}+              deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Response where+  mergeAppend (Response x'1 x'2 x'3 x'4 x'5) (Response y'1 y'2 y'3 y'4 y'5)+   = Response (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+      (P'.mergeAppend x'5 y'5)+ +instance P'.Default Response where+  defaultValue = Response P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire Response where+  wireSize ft' self'@(Response x'1 x'2 x'3 x'4 x'5)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size+         = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeReq 1 3 x'2 + P'.wireSizeRep 1 9 x'3 + P'.wireSizeOpt 1 9 x'4 ++             P'.wireSizeOpt 1 11 x'5)+  wirePut ft' self'@(Response x'1 x'2 x'3 x'4 x'5)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutReq 16 3 x'2+             P'.wirePutRep 26 9 x'3+             P'.wirePutOpt 34 9 x'4+             P'.wirePutOpt 42 11 x'5+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{status_code = new'Field}) (P'.wireGet 14)+             16 -> Prelude'.fmap (\ !new'Field -> old'Self{token = new'Field}) (P'.wireGet 3)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{response = P'.append (response old'Self) new'Field}) (P'.wireGet 9)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{error_message = Prelude'.Just new'Field}) (P'.wireGet 9)+             42 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{backtrace = P'.mergeAppend (backtrace old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Response) Response where+  getVal m' f' = f' m'+ +instance P'.GPB Response+ +instance P'.ReflectDescriptor Response where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8, 16]) (P'.fromDistinctAscList [8, 16, 26, 34, 42])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Response\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Response\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Response.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.status_code\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"status_code\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Response.StatusCode\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"StatusCode\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"token\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.response\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"response\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.error_message\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"error_message\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.backtrace\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"backtrace\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Response.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"Backtrace\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs view
@@ -0,0 +1,57 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Response.Backtrace (Backtrace(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data Backtrace = Backtrace{frame :: !(P'.Seq P'.Utf8)}+               deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Backtrace where+  mergeAppend (Backtrace x'1) (Backtrace y'1) = Backtrace (P'.mergeAppend x'1 y'1)+ +instance P'.Default Backtrace where+  defaultValue = Backtrace P'.defaultValue+ +instance P'.Wire Backtrace where+  wireSize ft' self'@(Backtrace x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeRep 1 9 x'1)+  wirePut ft' self'@(Backtrace x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutRep 10 9 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{frame = P'.append (frame old'Self) new'Field}) (P'.wireGet 9)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Backtrace) Backtrace where+  getVal m' f' = f' m'+ +instance P'.GPB Backtrace+ +instance P'.ReflectDescriptor Backtrace where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Response.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"Backtrace\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Response\",\"Backtrace.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.Backtrace.frame\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\",MName \"Backtrace\"], baseName' = FName \"frame\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs view
@@ -0,0 +1,92 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Response.StatusCode (StatusCode(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data StatusCode = SUCCESS_EMPTY+                | SUCCESS_JSON+                | SUCCESS_PARTIAL+                | SUCCESS_STREAM+                | BROKEN_CLIENT+                | BAD_QUERY+                | RUNTIME_ERROR+                deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable StatusCode+ +instance Prelude'.Bounded StatusCode where+  minBound = SUCCESS_EMPTY+  maxBound = RUNTIME_ERROR+ +instance P'.Default StatusCode where+  defaultValue = SUCCESS_EMPTY+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe StatusCode+toMaybe'Enum 0 = Prelude'.Just SUCCESS_EMPTY+toMaybe'Enum 1 = Prelude'.Just SUCCESS_JSON+toMaybe'Enum 2 = Prelude'.Just SUCCESS_PARTIAL+toMaybe'Enum 3 = Prelude'.Just SUCCESS_STREAM+toMaybe'Enum 101 = Prelude'.Just BROKEN_CLIENT+toMaybe'Enum 102 = Prelude'.Just BAD_QUERY+toMaybe'Enum 103 = Prelude'.Just RUNTIME_ERROR+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum StatusCode where+  fromEnum SUCCESS_EMPTY = 0+  fromEnum SUCCESS_JSON = 1+  fromEnum SUCCESS_PARTIAL = 2+  fromEnum SUCCESS_STREAM = 3+  fromEnum BROKEN_CLIENT = 101+  fromEnum BAD_QUERY = 102+  fromEnum RUNTIME_ERROR = 103+  toEnum+   = P'.fromMaybe+      (Prelude'.error+        "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode")+      . toMaybe'Enum+  succ SUCCESS_EMPTY = SUCCESS_JSON+  succ SUCCESS_JSON = SUCCESS_PARTIAL+  succ SUCCESS_PARTIAL = SUCCESS_STREAM+  succ SUCCESS_STREAM = BROKEN_CLIENT+  succ BROKEN_CLIENT = BAD_QUERY+  succ BAD_QUERY = RUNTIME_ERROR+  succ _+   = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode"+  pred SUCCESS_JSON = SUCCESS_EMPTY+  pred SUCCESS_PARTIAL = SUCCESS_JSON+  pred SUCCESS_STREAM = SUCCESS_PARTIAL+  pred BROKEN_CLIENT = SUCCESS_STREAM+  pred BAD_QUERY = BROKEN_CLIENT+  pred RUNTIME_ERROR = BAD_QUERY+  pred _+   = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode"+ +instance P'.Wire StatusCode where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB StatusCode+ +instance P'.MessageAPI msg' (msg' -> StatusCode) StatusCode where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum StatusCode where+  reflectEnum+   = [(0, "SUCCESS_EMPTY", SUCCESS_EMPTY), (1, "SUCCESS_JSON", SUCCESS_JSON), (2, "SUCCESS_PARTIAL", SUCCESS_PARTIAL),+      (3, "SUCCESS_STREAM", SUCCESS_STREAM), (101, "BROKEN_CLIENT", BROKEN_CLIENT), (102, "BAD_QUERY", BAD_QUERY),+      (103, "RUNTIME_ERROR", RUNTIME_ERROR)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.Response.StatusCode") ["Database", "RethinkDB", "Internal"]+        ["Query_Language", "Response"]+        "StatusCode")+      ["Database", "RethinkDB", "Internal", "Query_Language", "Response", "StatusCode.hs"]+      [(0, "SUCCESS_EMPTY"), (1, "SUCCESS_JSON"), (2, "SUCCESS_PARTIAL"), (3, "SUCCESS_STREAM"), (101, "BROKEN_CLIENT"),+       (102, "BAD_QUERY"), (103, "RUNTIME_ERROR")]
+ Database/RethinkDB/Internal/Query_Language/TableRef.hs view
@@ -0,0 +1,62 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.TableRef (TableRef(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data TableRef = TableRef{db_name :: !P'.Utf8, table_name :: !P'.Utf8, use_outdated :: !(P'.Maybe P'.Bool)}+              deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable TableRef where+  mergeAppend (TableRef x'1 x'2 x'3) (TableRef y'1 y'2 y'3)+   = TableRef (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default TableRef where+  defaultValue = TableRef P'.defaultValue P'.defaultValue (Prelude'.Just Prelude'.False)+ +instance P'.Wire TableRef where+  wireSize ft' self'@(TableRef x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeOpt 1 8 x'3)+  wirePut ft' self'@(TableRef x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutOpt 24 8 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{db_name = new'Field}) (P'.wireGet 9)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{table_name = new'Field}) (P'.wireGet 9)+             24 -> Prelude'.fmap (\ !new'Field -> old'Self{use_outdated = Prelude'.Just new'Field}) (P'.wireGet 8)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> TableRef) TableRef where+  getVal m' f' = f' m'+ +instance P'.GPB TableRef+ +instance P'.ReflectDescriptor TableRef where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18, 24])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"TableRef.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.db_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"db_name\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.table_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"table_name\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.use_outdated\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"use_outdated\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"false\", hsDefault = Just (HsDef'Bool False)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term.hs view
@@ -0,0 +1,150 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term (Term(..)) where+import Prelude ((+), (/), (==), (<=), (&&))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Term.Call as Query_Language.Term (Call)+import qualified Database.RethinkDB.Internal.Query_Language.Term.GetByKey as Query_Language.Term (GetByKey)+import qualified Database.RethinkDB.Internal.Query_Language.Term.If as Query_Language.Term (If)+import qualified Database.RethinkDB.Internal.Query_Language.Term.Let as Query_Language.Term (Let)+import qualified Database.RethinkDB.Internal.Query_Language.Term.Table as Query_Language.Term (Table)+import qualified Database.RethinkDB.Internal.Query_Language.Term.TermType as Query_Language.Term (TermType)+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as Query_Language (VarTermTuple)+ +data Term = Term{type' :: !Query_Language.Term.TermType, var :: !(P'.Maybe P'.Utf8), let' :: !(P'.Maybe Query_Language.Term.Let),+                 call :: !(P'.Maybe Query_Language.Term.Call), if_ :: !(P'.Maybe Query_Language.Term.If),+                 error :: !(P'.Maybe P'.Utf8), number :: !(P'.Maybe P'.Double), valuestring :: !(P'.Maybe P'.Utf8),+                 jsonstring :: !(P'.Maybe P'.Utf8), valuebool :: !(P'.Maybe P'.Bool), array :: !(P'.Seq Term),+                 object :: !(P'.Seq Query_Language.VarTermTuple), get_by_key :: !(P'.Maybe Query_Language.Term.GetByKey),+                 table :: !(P'.Maybe Query_Language.Term.Table), javascript :: !(P'.Maybe P'.Utf8), ext'field :: !P'.ExtField}+          deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.ExtendMessage Term where+  getExtField = ext'field+  putExtField e'f msg = msg{ext'field = e'f}+  validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)+ +instance P'.Mergeable Term where+  mergeAppend (Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)+   (Term y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10 y'11 y'12 y'13 y'14 y'15 y'16)+   = Term (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+      (P'.mergeAppend x'5 y'5)+      (P'.mergeAppend x'6 y'6)+      (P'.mergeAppend x'7 y'7)+      (P'.mergeAppend x'8 y'8)+      (P'.mergeAppend x'9 y'9)+      (P'.mergeAppend x'10 y'10)+      (P'.mergeAppend x'11 y'11)+      (P'.mergeAppend x'12 y'12)+      (P'.mergeAppend x'13 y'13)+      (P'.mergeAppend x'14 y'14)+      (P'.mergeAppend x'15 y'15)+      (P'.mergeAppend x'16 y'16)+ +instance P'.Default Term where+  defaultValue+   = Term P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+ +instance P'.Wire Term where+  wireSize ft' self'@(Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size+         = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 ++             P'.wireSizeOpt 1 11 x'5+             + P'.wireSizeOpt 1 9 x'6+             + P'.wireSizeOpt 1 1 x'7+             + P'.wireSizeOpt 1 9 x'8+             + P'.wireSizeOpt 1 9 x'9+             + P'.wireSizeOpt 1 8 x'10+             + P'.wireSizeRep 1 11 x'11+             + P'.wireSizeRep 1 11 x'12+             + P'.wireSizeOpt 1 11 x'13+             + P'.wireSizeOpt 1 11 x'14+             + P'.wireSizeOpt 2 9 x'15+             + P'.wireSizeExtField x'16)+  wirePut ft' self'@(Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutOpt 18 9 x'2+             P'.wirePutOpt 26 11 x'3+             P'.wirePutOpt 34 11 x'4+             P'.wirePutOpt 42 11 x'5+             P'.wirePutOpt 50 9 x'6+             P'.wirePutOpt 57 1 x'7+             P'.wirePutOpt 66 9 x'8+             P'.wirePutOpt 74 9 x'9+             P'.wirePutOpt 80 8 x'10+             P'.wirePutRep 90 11 x'11+             P'.wirePutRep 98 11 x'12+             P'.wirePutOpt 114 11 x'13+             P'.wirePutOpt 122 11 x'14+             P'.wirePutOpt 130 9 x'15+             P'.wirePutExtField x'16+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{var = Prelude'.Just new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{let' = P'.mergeAppend (let' old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{call = P'.mergeAppend (call old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             42 -> Prelude'.fmap (\ !new'Field -> old'Self{if_ = P'.mergeAppend (if_ old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             50 -> Prelude'.fmap (\ !new'Field -> old'Self{error = Prelude'.Just new'Field}) (P'.wireGet 9)+             57 -> Prelude'.fmap (\ !new'Field -> old'Self{number = Prelude'.Just new'Field}) (P'.wireGet 1)+             66 -> Prelude'.fmap (\ !new'Field -> old'Self{valuestring = Prelude'.Just new'Field}) (P'.wireGet 9)+             74 -> Prelude'.fmap (\ !new'Field -> old'Self{jsonstring = Prelude'.Just new'Field}) (P'.wireGet 9)+             80 -> Prelude'.fmap (\ !new'Field -> old'Self{valuebool = Prelude'.Just new'Field}) (P'.wireGet 8)+             90 -> Prelude'.fmap (\ !new'Field -> old'Self{array = P'.append (array old'Self) new'Field}) (P'.wireGet 11)+             98 -> Prelude'.fmap (\ !new'Field -> old'Self{object = P'.append (object old'Self) new'Field}) (P'.wireGet 11)+             114 -> Prelude'.fmap+                     (\ !new'Field -> old'Self{get_by_key = P'.mergeAppend (get_by_key old'Self) (Prelude'.Just new'Field)})+                     (P'.wireGet 11)+             122 -> Prelude'.fmap (\ !new'Field -> old'Self{table = P'.mergeAppend (table old'Self) (Prelude'.Just new'Field)})+                     (P'.wireGet 11)+             130 -> Prelude'.fmap (\ !new'Field -> old'Self{javascript = Prelude'.Just new'Field}) (P'.wireGet 9)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in+                   if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then+                    P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Term) Term where+  getVal m' f' = f' m'+ +instance P'.GPB Term+ +instance P'.ReflectDescriptor Term where+  getMessageInfo _+   = P'.GetMessageInfo (P'.fromDistinctAscList [8])+      (P'.fromDistinctAscList [8, 18, 26, 34, 42, 50, 57, 66, 74, 80, 90, 98, 114, 122, 130])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.TermType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"TermType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.let\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"let'\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Let\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Let\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.call\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"call\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Call\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Call\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.if_\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"if_\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.If\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"If\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.error\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"error\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.number\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"number\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 57}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 1}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.valuestring\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"valuestring\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.jsonstring\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"jsonstring\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.valuebool\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"valuebool\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 80}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.array\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"array\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 90}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.object\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"object\"}, fieldNumber = FieldId {getFieldId = 12}, wireTag = WireTag {getWireTag = 98}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.get_by_key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"get_by_key\"}, fieldNumber = FieldId {getFieldId = 14}, wireTag = WireTag {getWireTag = 114}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.GetByKey\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"GetByKey\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"table\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Table\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Table\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.javascript\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"javascript\"}, fieldNumber = FieldId {getFieldId = 16}, wireTag = WireTag {getWireTag = 130}, packedTag = Nothing, wireTagLength = 2, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term.hs-boot view
@@ -0,0 +1,32 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term (Term) where+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data Term+ +instance P'.MessageAPI msg' (msg' -> Term) Term+ +instance Prelude'.Show Term+ +instance Prelude'.Eq Term+ +instance Prelude'.Ord Term+ +instance Prelude'.Typeable Term+ +instance Prelude'.Data Term+ +instance P'.Mergeable Term+ +instance P'.Default Term+ +instance P'.Wire Term+ +instance P'.GPB Term+ +instance P'.ReflectDescriptor Term+ +instance P'.ExtendMessage Term
+ Database/RethinkDB/Internal/Query_Language/Term/Call.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.Call (Call(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as Query_Language (Builtin)+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Call = Call{builtin :: !Query_Language.Builtin, args :: !(P'.Seq Query_Language.Term)}+          deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Call where+  mergeAppend (Call x'1 x'2) (Call y'1 y'2) = Call (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default Call where+  defaultValue = Call P'.defaultValue P'.defaultValue+ +instance P'.Wire Call where+  wireSize ft' self'@(Call x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeRep 1 11 x'2)+  wirePut ft' self'@(Call x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutRep 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{builtin = P'.mergeAppend (builtin old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{args = P'.append (args old'Self) new'Field}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Call) Call where+  getVal m' f' = f' m'+ +instance P'.GPB Call+ +instance P'.ReflectDescriptor Call where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Call\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Call\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Call.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Call.builtin\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Call\"], baseName' = FName \"builtin\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Builtin\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Call.args\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Call\"], baseName' = FName \"args\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs view
@@ -0,0 +1,65 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.GetByKey (GetByKey(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data GetByKey = GetByKey{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term}+              deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable GetByKey where+  mergeAppend (GetByKey x'1 x'2 x'3) (GetByKey y'1 y'2 y'3)+   = GetByKey (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default GetByKey where+  defaultValue = GetByKey P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire GetByKey where+  wireSize ft' self'@(GetByKey x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3)+  wirePut ft' self'@(GetByKey x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutReq 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> GetByKey) GetByKey where+  getVal m' f' = f' m'+ +instance P'.GPB GetByKey+ +instance P'.ReflectDescriptor GetByKey where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.GetByKey\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"GetByKey\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"GetByKey.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term/If.hs view
@@ -0,0 +1,64 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.If (If(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data If = If{test :: !Query_Language.Term, true_branch :: !Query_Language.Term, false_branch :: !Query_Language.Term}+        deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable If where+  mergeAppend (If x'1 x'2 x'3) (If y'1 y'2 y'3) = If (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default If where+  defaultValue = If P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire If where+  wireSize ft' self'@(If x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeReq 1 11 x'3)+  wirePut ft' self'@(If x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 11 x'2+             P'.wirePutReq 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{test = P'.mergeAppend (test old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{true_branch = P'.mergeAppend (true_branch old'Self) (new'Field)})+                    (P'.wireGet 11)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{false_branch = P'.mergeAppend (false_branch old'Self) (new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> If) If where+  getVal m' f' = f' m'+ +instance P'.GPB If+ +instance P'.ReflectDescriptor If where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.If\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"If\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"If.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.test\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"test\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.true_branch\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"true_branch\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.false_branch\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"false_branch\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term/Let.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.Let (Let(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as Query_Language (VarTermTuple)+ +data Let = Let{binds :: !(P'.Seq Query_Language.VarTermTuple), expr :: !Query_Language.Term}+         deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Let where+  mergeAppend (Let x'1 x'2) (Let y'1 y'2) = Let (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default Let where+  defaultValue = Let P'.defaultValue P'.defaultValue+ +instance P'.Wire Let where+  wireSize ft' self'@(Let x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeRep 1 11 x'1 + P'.wireSizeReq 1 11 x'2)+  wirePut ft' self'@(Let x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutRep 10 11 x'1+             P'.wirePutReq 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{binds = P'.append (binds old'Self) new'Field}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{expr = P'.mergeAppend (expr old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Let) Let where+  getVal m' f' = f' m'+ +instance P'.GPB Let+ +instance P'.ReflectDescriptor Let where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Let\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Let\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Let.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Let.binds\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Let\"], baseName' = FName \"binds\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Let.expr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Let\"], baseName' = FName \"expr\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term/Table.hs view
@@ -0,0 +1,59 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.Table (Table(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+ +data Table = Table{table_ref :: !Query_Language.TableRef}+           deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Table where+  mergeAppend (Table x'1) (Table y'1) = Table (P'.mergeAppend x'1 y'1)+ +instance P'.Default Table where+  defaultValue = Table P'.defaultValue+ +instance P'.Wire Table where+  wireSize ft' self'@(Table x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1)+  wirePut ft' self'@(Table x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Table) Table where+  getVal m' f' = f' m'+ +instance P'.GPB Table+ +instance P'.ReflectDescriptor Table where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Table\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Table\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Table.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Table.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Table\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/Term/TermType.hs view
@@ -0,0 +1,134 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.Term.TermType (TermType(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data TermType = JSON_NULL+              | VAR+              | LET+              | CALL+              | IF+              | ERROR+              | NUMBER+              | STRING+              | JSON+              | BOOL+              | ARRAY+              | OBJECT+              | GETBYKEY+              | TABLE+              | JAVASCRIPT+              | IMPLICIT_VAR+              deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable TermType+ +instance Prelude'.Bounded TermType where+  minBound = JSON_NULL+  maxBound = IMPLICIT_VAR+ +instance P'.Default TermType where+  defaultValue = JSON_NULL+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe TermType+toMaybe'Enum 0 = Prelude'.Just JSON_NULL+toMaybe'Enum 1 = Prelude'.Just VAR+toMaybe'Enum 2 = Prelude'.Just LET+toMaybe'Enum 3 = Prelude'.Just CALL+toMaybe'Enum 4 = Prelude'.Just IF+toMaybe'Enum 5 = Prelude'.Just ERROR+toMaybe'Enum 6 = Prelude'.Just NUMBER+toMaybe'Enum 7 = Prelude'.Just STRING+toMaybe'Enum 8 = Prelude'.Just JSON+toMaybe'Enum 9 = Prelude'.Just BOOL+toMaybe'Enum 10 = Prelude'.Just ARRAY+toMaybe'Enum 11 = Prelude'.Just OBJECT+toMaybe'Enum 12 = Prelude'.Just GETBYKEY+toMaybe'Enum 13 = Prelude'.Just TABLE+toMaybe'Enum 14 = Prelude'.Just JAVASCRIPT+toMaybe'Enum 15 = Prelude'.Just IMPLICIT_VAR+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum TermType where+  fromEnum JSON_NULL = 0+  fromEnum VAR = 1+  fromEnum LET = 2+  fromEnum CALL = 3+  fromEnum IF = 4+  fromEnum ERROR = 5+  fromEnum NUMBER = 6+  fromEnum STRING = 7+  fromEnum JSON = 8+  fromEnum BOOL = 9+  fromEnum ARRAY = 10+  fromEnum OBJECT = 11+  fromEnum GETBYKEY = 12+  fromEnum TABLE = 13+  fromEnum JAVASCRIPT = 14+  fromEnum IMPLICIT_VAR = 15+  toEnum+   = P'.fromMaybe+      (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType")+      . toMaybe'Enum+  succ JSON_NULL = VAR+  succ VAR = LET+  succ LET = CALL+  succ CALL = IF+  succ IF = ERROR+  succ ERROR = NUMBER+  succ NUMBER = STRING+  succ STRING = JSON+  succ JSON = BOOL+  succ BOOL = ARRAY+  succ ARRAY = OBJECT+  succ OBJECT = GETBYKEY+  succ GETBYKEY = TABLE+  succ TABLE = JAVASCRIPT+  succ JAVASCRIPT = IMPLICIT_VAR+  succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType"+  pred VAR = JSON_NULL+  pred LET = VAR+  pred CALL = LET+  pred IF = CALL+  pred ERROR = IF+  pred NUMBER = ERROR+  pred STRING = NUMBER+  pred JSON = STRING+  pred BOOL = JSON+  pred ARRAY = BOOL+  pred OBJECT = ARRAY+  pred GETBYKEY = OBJECT+  pred TABLE = GETBYKEY+  pred JAVASCRIPT = TABLE+  pred IMPLICIT_VAR = JAVASCRIPT+  pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType"+ +instance P'.Wire TermType where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB TermType+ +instance P'.MessageAPI msg' (msg' -> TermType) TermType where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum TermType where+  reflectEnum+   = [(0, "JSON_NULL", JSON_NULL), (1, "VAR", VAR), (2, "LET", LET), (3, "CALL", CALL), (4, "IF", IF), (5, "ERROR", ERROR),+      (6, "NUMBER", NUMBER), (7, "STRING", STRING), (8, "JSON", JSON), (9, "BOOL", BOOL), (10, "ARRAY", ARRAY),+      (11, "OBJECT", OBJECT), (12, "GETBYKEY", GETBYKEY), (13, "TABLE", TABLE), (14, "JAVASCRIPT", JAVASCRIPT),+      (15, "IMPLICIT_VAR", IMPLICIT_VAR)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.Term.TermType") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Term"]+        "TermType")+      ["Database", "RethinkDB", "Internal", "Query_Language", "Term", "TermType.hs"]+      [(0, "JSON_NULL"), (1, "VAR"), (2, "LET"), (3, "CALL"), (4, "IF"), (5, "ERROR"), (6, "NUMBER"), (7, "STRING"), (8, "JSON"),+       (9, "BOOL"), (10, "ARRAY"), (11, "OBJECT"), (12, "GETBYKEY"), (13, "TABLE"), (14, "JAVASCRIPT"), (15, "IMPLICIT_VAR")]
+ Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs view
@@ -0,0 +1,60 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.VarTermTuple (VarTermTuple(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data VarTermTuple = VarTermTuple{var :: !P'.Utf8, term :: !Query_Language.Term}+                  deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable VarTermTuple where+  mergeAppend (VarTermTuple x'1 x'2) (VarTermTuple y'1 y'2) = VarTermTuple (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default VarTermTuple where+  defaultValue = VarTermTuple P'.defaultValue P'.defaultValue+ +instance P'.Wire VarTermTuple where+  wireSize ft' self'@(VarTermTuple x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2)+  wirePut ft' self'@(VarTermTuple x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 9 x'1+             P'.wirePutReq 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{var = new'Field}) (P'.wireGet 9)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{term = P'.mergeAppend (term old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> VarTermTuple) VarTermTuple where+  getVal m' f' = f' m'+ +instance P'.GPB VarTermTuple+ +instance P'.ReflectDescriptor VarTermTuple where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"VarTermTuple.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.VarTermTuple.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"VarTermTuple\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.VarTermTuple.term\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"VarTermTuple\"], baseName' = FName \"term\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery.hs view
@@ -0,0 +1,122 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery (WriteQuery(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete as Query_Language.WriteQuery (Delete)+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach as Query_Language.WriteQuery (ForEach)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert as Query_Language.WriteQuery (Insert)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate as Query_Language.WriteQuery (Mutate)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete as Query_Language.WriteQuery (PointDelete)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate as Query_Language.WriteQuery (PointMutate)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate as Query_Language.WriteQuery (PointUpdate)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Update as Query_Language.WriteQuery (Update)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType as Query_Language.WriteQuery (WriteQueryType)+ +data WriteQuery = WriteQuery{type' :: !Query_Language.WriteQuery.WriteQueryType, atomic :: !(P'.Maybe P'.Bool),+                             update :: !(P'.Maybe Query_Language.WriteQuery.Update),+                             delete :: !(P'.Maybe Query_Language.WriteQuery.Delete),+                             mutate :: !(P'.Maybe Query_Language.WriteQuery.Mutate),+                             insert :: !(P'.Maybe Query_Language.WriteQuery.Insert),+                             for_each :: !(P'.Maybe Query_Language.WriteQuery.ForEach),+                             point_update :: !(P'.Maybe Query_Language.WriteQuery.PointUpdate),+                             point_delete :: !(P'.Maybe Query_Language.WriteQuery.PointDelete),+                             point_mutate :: !(P'.Maybe Query_Language.WriteQuery.PointMutate)}+                deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable WriteQuery where+  mergeAppend (WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10) (WriteQuery y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10)+   = WriteQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+      (P'.mergeAppend x'5 y'5)+      (P'.mergeAppend x'6 y'6)+      (P'.mergeAppend x'7 y'7)+      (P'.mergeAppend x'8 y'8)+      (P'.mergeAppend x'9 y'9)+      (P'.mergeAppend x'10 y'10)+ +instance P'.Default WriteQuery where+  defaultValue+   = WriteQuery P'.defaultValue (Prelude'.Just Prelude'.True) P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+      P'.defaultValue+ +instance P'.Wire WriteQuery where+  wireSize ft' self'@(WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size+         = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 8 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 ++             P'.wireSizeOpt 1 11 x'5+             + P'.wireSizeOpt 1 11 x'6+             + P'.wireSizeOpt 1 11 x'7+             + P'.wireSizeOpt 1 11 x'8+             + P'.wireSizeOpt 1 11 x'9+             + P'.wireSizeOpt 1 11 x'10)+  wirePut ft' self'@(WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 8 14 x'1+             P'.wirePutOpt 18 11 x'3+             P'.wirePutOpt 26 11 x'4+             P'.wirePutOpt 34 11 x'5+             P'.wirePutOpt 42 11 x'6+             P'.wirePutOpt 58 11 x'7+             P'.wirePutOpt 66 11 x'8+             P'.wirePutOpt 74 11 x'9+             P'.wirePutOpt 82 11 x'10+             P'.wirePutOpt 88 8 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)+             88 -> Prelude'.fmap (\ !new'Field -> old'Self{atomic = Prelude'.Just new'Field}) (P'.wireGet 8)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{update = P'.mergeAppend (update old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{delete = P'.mergeAppend (delete old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{mutate = P'.mergeAppend (mutate old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             42 -> Prelude'.fmap (\ !new'Field -> old'Self{insert = P'.mergeAppend (insert old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             58 -> Prelude'.fmap (\ !new'Field -> old'Self{for_each = P'.mergeAppend (for_each old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             66 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{point_update = P'.mergeAppend (point_update old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             74 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{point_delete = P'.mergeAppend (point_delete old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             82 -> Prelude'.fmap+                    (\ !new'Field -> old'Self{point_mutate = P'.mergeAppend (point_mutate old'Self) (Prelude'.Just new'Field)})+                    (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> WriteQuery) WriteQuery where+  getVal m' f' = f' m'+ +instance P'.GPB WriteQuery+ +instance P'.ReflectDescriptor WriteQuery where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 34, 42, 58, 66, 74, 82, 88])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.WriteQueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"WriteQueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.atomic\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"atomic\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 88}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"true\", hsDefault = Just (HsDef'Bool True)},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.update\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"update\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Update\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Update\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.delete\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"delete\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Delete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Delete\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.mutate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"mutate\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Mutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Mutate\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.insert\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"insert\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Insert\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Insert\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.for_each\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"for_each\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 58}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.ForEach\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"ForEach\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_update\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_update\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointUpdate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointUpdate\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_delete\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_delete\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointDelete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointDelete\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_mutate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_mutate\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 82}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointMutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointMutate\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs view
@@ -0,0 +1,58 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete (Delete(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Delete = Delete{view :: !Query_Language.Term}+            deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Delete where+  mergeAppend (Delete x'1) (Delete y'1) = Delete (P'.mergeAppend x'1 y'1)+ +instance P'.Default Delete where+  defaultValue = Delete P'.defaultValue+ +instance P'.Wire Delete where+  wireSize ft' self'@(Delete x'1)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1)+  wirePut ft' self'@(Delete x'1)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Delete) Delete where+  getVal m' f' = f' m'+ +instance P'.GPB Delete+ +instance P'.ReflectDescriptor Delete where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Delete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Delete\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Delete.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Delete.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Delete\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs view
@@ -0,0 +1,64 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach (ForEach(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as Query_Language (WriteQuery)+ +data ForEach = ForEach{stream :: !Query_Language.Term, var :: !P'.Utf8, queries :: !(P'.Seq Query_Language.WriteQuery)}+             deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable ForEach where+  mergeAppend (ForEach x'1 x'2 x'3) (ForEach y'1 y'2 y'3)+   = ForEach (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default ForEach where+  defaultValue = ForEach P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire ForEach where+  wireSize ft' self'@(ForEach x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeRep 1 11 x'3)+  wirePut ft' self'@(ForEach x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutRep 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{stream = P'.mergeAppend (stream old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{var = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{queries = P'.append (queries old'Self) new'Field}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> ForEach) ForEach where+  getVal m' f' = f' m'+ +instance P'.GPB ForEach+ +instance P'.ReflectDescriptor ForEach where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.ForEach\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"ForEach\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"ForEach.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.stream\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"stream\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.queries\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"queries\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot view
@@ -0,0 +1,30 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach (ForEach) where+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data ForEach+ +instance P'.MessageAPI msg' (msg' -> ForEach) ForEach+ +instance Prelude'.Show ForEach+ +instance Prelude'.Eq ForEach+ +instance Prelude'.Ord ForEach+ +instance Prelude'.Typeable ForEach+ +instance Prelude'.Data ForEach+ +instance P'.Mergeable ForEach+ +instance P'.Default ForEach+ +instance P'.Wire ForEach+ +instance P'.GPB ForEach+ +instance P'.ReflectDescriptor ForEach
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs view
@@ -0,0 +1,66 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert (Insert(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Insert = Insert{table_ref :: !Query_Language.TableRef, terms :: !(P'.Seq Query_Language.Term),+                     overwrite :: !(P'.Maybe P'.Bool)}+            deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Insert where+  mergeAppend (Insert x'1 x'2 x'3) (Insert y'1 y'2 y'3)+   = Insert (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default Insert where+  defaultValue = Insert P'.defaultValue P'.defaultValue (Prelude'.Just Prelude'.False)+ +instance P'.Wire Insert where+  wireSize ft' self'@(Insert x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeRep 1 11 x'2 + P'.wireSizeOpt 1 8 x'3)+  wirePut ft' self'@(Insert x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutRep 18 11 x'2+             P'.wirePutOpt 24 8 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{terms = P'.append (terms old'Self) new'Field}) (P'.wireGet 11)+             24 -> Prelude'.fmap (\ !new'Field -> old'Self{overwrite = Prelude'.Just new'Field}) (P'.wireGet 8)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Insert) Insert where+  getVal m' f' = f' m'+ +instance P'.GPB Insert+ +instance P'.ReflectDescriptor Insert where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18, 24])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Insert\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Insert\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Insert.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.terms\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"terms\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.overwrite\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"overwrite\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"false\", hsDefault = Just (HsDef'Bool False)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate (Mutate(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Mutate = Mutate{view :: !Query_Language.Term, mapping :: !Query_Language.Mapping}+            deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Mutate where+  mergeAppend (Mutate x'1 x'2) (Mutate y'1 y'2) = Mutate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default Mutate where+  defaultValue = Mutate P'.defaultValue P'.defaultValue+ +instance P'.Wire Mutate where+  wireSize ft' self'@(Mutate x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2)+  wirePut ft' self'@(Mutate x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Mutate) Mutate where+  getVal m' f' = f' m'+ +instance P'.GPB Mutate+ +instance P'.ReflectDescriptor Mutate where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Mutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Mutate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Mutate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Mutate.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Mutate\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Mutate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Mutate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs view
@@ -0,0 +1,65 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete (PointDelete(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data PointDelete = PointDelete{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term}+                 deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable PointDelete where+  mergeAppend (PointDelete x'1 x'2 x'3) (PointDelete y'1 y'2 y'3)+   = PointDelete (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default PointDelete where+  defaultValue = PointDelete P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire PointDelete where+  wireSize ft' self'@(PointDelete x'1 x'2 x'3)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3)+  wirePut ft' self'@(PointDelete x'1 x'2 x'3)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutReq 26 11 x'3+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> PointDelete) PointDelete where+  getVal m' f' = f' m'+ +instance P'.GPB PointDelete+ +instance P'.ReflectDescriptor PointDelete where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointDelete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointDelete\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointDelete.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs view
@@ -0,0 +1,69 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate (PointMutate(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data PointMutate = PointMutate{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term,+                               mapping :: !Query_Language.Mapping}+                 deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable PointMutate where+  mergeAppend (PointMutate x'1 x'2 x'3 x'4) (PointMutate y'1 y'2 y'3 y'4)+   = PointMutate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default PointMutate where+  defaultValue = PointMutate P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire PointMutate where+  wireSize ft' self'@(PointMutate x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3 + P'.wireSizeReq 1 11 x'4)+  wirePut ft' self'@(PointMutate x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutReq 26 11 x'3+             P'.wirePutReq 34 11 x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> PointMutate) PointMutate where+  getVal m' f' = f' m'+ +instance P'.GPB PointMutate+ +instance P'.ReflectDescriptor PointMutate where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointMutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointMutate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointMutate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs view
@@ -0,0 +1,69 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate (PointUpdate(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data PointUpdate = PointUpdate{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term,+                               mapping :: !Query_Language.Mapping}+                 deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable PointUpdate where+  mergeAppend (PointUpdate x'1 x'2 x'3 x'4) (PointUpdate y'1 y'2 y'3 y'4)+   = PointUpdate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default PointUpdate where+  defaultValue = PointUpdate P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire PointUpdate where+  wireSize ft' self'@(PointUpdate x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3 + P'.wireSizeReq 1 11 x'4)+  wirePut ft' self'@(PointUpdate x'1 x'2 x'3 x'4)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 9 x'2+             P'.wirePutReq 26 11 x'3+             P'.wirePutReq 34 11 x'4+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})+                    (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)+             26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)+             34 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> PointUpdate) PointUpdate where+  getVal m' f' = f' m'+ +instance P'.GPB PointUpdate+ +instance P'.ReflectDescriptor PointUpdate where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointUpdate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointUpdate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointUpdate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Update (Update(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)+ +data Update = Update{view :: !Query_Language.Term, mapping :: !Query_Language.Mapping}+            deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable Update where+  mergeAppend (Update x'1 x'2) (Update y'1 y'2) = Update (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)+ +instance P'.Default Update where+  defaultValue = Update P'.defaultValue P'.defaultValue+ +instance P'.Wire Update where+  wireSize ft' self'@(Update x'1 x'2)+   = case ft' of+       10 -> calc'Size+       11 -> P'.prependMessageSize calc'Size+       _ -> P'.wireSizeErr ft' self'+    where+        calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2)+  wirePut ft' self'@(Update x'1 x'2)+   = case ft' of+       10 -> put'Fields+       11 -> do+               P'.putSize (P'.wireSize 10 self')+               put'Fields+       _ -> P'.wirePutErr ft' self'+    where+        put'Fields+         = do+             P'.wirePutReq 10 11 x'1+             P'.wirePutReq 18 11 x'2+  wireGet ft'+   = case ft' of+       10 -> P'.getBareMessageWith update'Self+       11 -> P'.getMessageWith update'Self+       _ -> P'.wireGetErr ft'+    where+        update'Self wire'Tag old'Self+         = case wire'Tag of+             10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)+             18 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)+             _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> Update) Update where+  getVal m' f' = f' m'+ +instance P'.GPB Update+ +instance P'.ReflectDescriptor Update where+  getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])+  reflectDescriptorInfo _+   = Prelude'.read+      "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Update\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Update\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Update.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Update.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Update\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Update.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Update\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
+ Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs view
@@ -0,0 +1,98 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType (WriteQueryType(..)) where+import Prelude ((+), (/), (.))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Data.Data as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data WriteQueryType = UPDATE+                    | DELETE+                    | MUTATE+                    | INSERT+                    | FOREACH+                    | POINTUPDATE+                    | POINTDELETE+                    | POINTMUTATE+                    deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)+ +instance P'.Mergeable WriteQueryType+ +instance Prelude'.Bounded WriteQueryType where+  minBound = UPDATE+  maxBound = POINTMUTATE+ +instance P'.Default WriteQueryType where+  defaultValue = UPDATE+ +toMaybe'Enum :: Prelude'.Int -> P'.Maybe WriteQueryType+toMaybe'Enum 1 = Prelude'.Just UPDATE+toMaybe'Enum 2 = Prelude'.Just DELETE+toMaybe'Enum 3 = Prelude'.Just MUTATE+toMaybe'Enum 4 = Prelude'.Just INSERT+toMaybe'Enum 6 = Prelude'.Just FOREACH+toMaybe'Enum 7 = Prelude'.Just POINTUPDATE+toMaybe'Enum 8 = Prelude'.Just POINTDELETE+toMaybe'Enum 9 = Prelude'.Just POINTMUTATE+toMaybe'Enum _ = Prelude'.Nothing+ +instance Prelude'.Enum WriteQueryType where+  fromEnum UPDATE = 1+  fromEnum DELETE = 2+  fromEnum MUTATE = 3+  fromEnum INSERT = 4+  fromEnum FOREACH = 6+  fromEnum POINTUPDATE = 7+  fromEnum POINTDELETE = 8+  fromEnum POINTMUTATE = 9+  toEnum+   = P'.fromMaybe+      (Prelude'.error+        "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType")+      . toMaybe'Enum+  succ UPDATE = DELETE+  succ DELETE = MUTATE+  succ MUTATE = INSERT+  succ INSERT = FOREACH+  succ FOREACH = POINTUPDATE+  succ POINTUPDATE = POINTDELETE+  succ POINTDELETE = POINTMUTATE+  succ _+   = Prelude'.error+      "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType"+  pred DELETE = UPDATE+  pred MUTATE = DELETE+  pred INSERT = MUTATE+  pred FOREACH = INSERT+  pred POINTUPDATE = FOREACH+  pred POINTDELETE = POINTUPDATE+  pred POINTMUTATE = POINTDELETE+  pred _+   = Prelude'.error+      "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType"+ +instance P'.Wire WriteQueryType where+  wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)+  wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)+  wireGet 14 = P'.wireGetEnum toMaybe'Enum+  wireGet ft' = P'.wireGetErr ft'+  wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum+  wireGetPacked ft' = P'.wireGetErr ft'+ +instance P'.GPB WriteQueryType+ +instance P'.MessageAPI msg' (msg' -> WriteQueryType) WriteQueryType where+  getVal m' f' = f' m'+ +instance P'.ReflectEnum WriteQueryType where+  reflectEnum+   = [(1, "UPDATE", UPDATE), (2, "DELETE", DELETE), (3, "MUTATE", MUTATE), (4, "INSERT", INSERT), (6, "FOREACH", FOREACH),+      (7, "POINTUPDATE", POINTUPDATE), (8, "POINTDELETE", POINTDELETE), (9, "POINTMUTATE", POINTMUTATE)]+  reflectEnumInfo _+   = P'.EnumInfo+      (P'.makePNF (P'.pack ".Query_Language.WriteQuery.WriteQueryType") ["Database", "RethinkDB", "Internal"]+        ["Query_Language", "WriteQuery"]+        "WriteQueryType")+      ["Database", "RethinkDB", "Internal", "Query_Language", "WriteQuery", "WriteQueryType.hs"]+      [(1, "UPDATE"), (2, "DELETE"), (3, "MUTATE"), (4, "INSERT"), (6, "FOREACH"), (7, "POINTUPDATE"), (8, "POINTDELETE"),+       (9, "POINTMUTATE")]
+ Database/RethinkDB/Internal/Types.hs view
@@ -0,0 +1,83 @@+module Database.RethinkDB.Internal.Types (+  module Database.RethinkDB.Internal.Query_Language.ReadQuery,+  module Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap,+  module Database.RethinkDB.Internal.Query_Language.Builtin.Comparison,+  module Database.RethinkDB.Internal.Query_Language.Builtin.Map,+  module Database.RethinkDB.Internal.Query_Language.Builtin.Filter,+  module Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce,+  module Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy,+  module Database.RethinkDB.Internal.Query_Language.Builtin.Range,+  module Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType,+  module Database.RethinkDB.Internal.Query_Language.Query,+  module Database.RethinkDB.Internal.Query_Language.Term,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.Update,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate,+  module Database.RethinkDB.Internal.Query_Language.Response,+  module Database.RethinkDB.Internal.Query_Language.VarTermTuple,+  module Database.RethinkDB.Internal.Query_Language.Reduction,+  module Database.RethinkDB.Internal.Query_Language.Term.Call,+  module Database.RethinkDB.Internal.Query_Language.Term.Table,+  module Database.RethinkDB.Internal.Query_Language.Term.GetByKey,+  module Database.RethinkDB.Internal.Query_Language.Term.Let,+  module Database.RethinkDB.Internal.Query_Language.Term.If,+  module Database.RethinkDB.Internal.Query_Language.Term.TermType,+  module Database.RethinkDB.Internal.Query_Language.Query.QueryType,+  module Database.RethinkDB.Internal.Query_Language.MetaQuery,+  module Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType,+  module Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable,+  module Database.RethinkDB.Internal.Query_Language.Predicate,+  module Database.RethinkDB.Internal.Query_Language.Builtin,+  module Database.RethinkDB.Internal.Query_Language.Response.StatusCode,+  module Database.RethinkDB.Internal.Query_Language.Response.Backtrace,+  module Database.RethinkDB.Internal.Query_Language.TableRef,+  module Database.RethinkDB.Internal.Query_Language.WriteQuery,+  module Database.RethinkDB.Internal.Query_Language.Mapping,+  ) where++import Database.RethinkDB.Internal.Query_Language.ReadQuery hiding (ext'field, term)+import Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap hiding (mapping)+import Database.RethinkDB.Internal.Query_Language.Builtin.Comparison+import Database.RethinkDB.Internal.Query_Language.Builtin.Map hiding (mapping)+import Database.RethinkDB.Internal.Query_Language.Builtin.Filter+import Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce+import Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy hiding (attr)+import Database.RethinkDB.Internal.Query_Language.Builtin.Range hiding (attrname)+import Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType+import Database.RethinkDB.Internal.Query_Language.Query hiding (token, type')+import Database.RethinkDB.Internal.Query_Language.Term hiding (ext'field, type', var)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete hiding (attrname, table_ref, key)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert hiding (table_ref)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Update hiding (mapping, view)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate hiding (key, table_ref, attrname)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete hiding (view)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach hiding (var)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate hiding (mapping, view)+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate hiding (key, table_ref, attrname, mapping)+import Database.RethinkDB.Internal.Query_Language.Response hiding (token)+import Database.RethinkDB.Internal.Query_Language.VarTermTuple hiding (var, term)+import Database.RethinkDB.Internal.Query_Language.Reduction hiding (body)+import Database.RethinkDB.Internal.Query_Language.Term.Call+import Database.RethinkDB.Internal.Query_Language.Term.Table hiding (table_ref)+import Database.RethinkDB.Internal.Query_Language.Term.GetByKey hiding (key, table_ref, attrname)+import Database.RethinkDB.Internal.Query_Language.Term.Let+import Database.RethinkDB.Internal.Query_Language.Term.If+import Database.RethinkDB.Internal.Query_Language.Term.TermType+import Database.RethinkDB.Internal.Query_Language.Query.QueryType+import Database.RethinkDB.Internal.Query_Language.MetaQuery hiding (type', db_name)+import Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType+import Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable hiding (table_ref)+import Database.RethinkDB.Internal.Query_Language.Predicate hiding (body, arg)+import Database.RethinkDB.Internal.Query_Language.Builtin hiding (attr, type')+import Database.RethinkDB.Internal.Query_Language.Response.StatusCode+import Database.RethinkDB.Internal.Query_Language.Response.Backtrace+import Database.RethinkDB.Internal.Query_Language.TableRef hiding (db_name)+import Database.RethinkDB.Internal.Query_Language.WriteQuery hiding (type')+import Database.RethinkDB.Internal.Query_Language.Mapping hiding (arg, body, ext'field)
+ Database/RethinkDB/Types.hs view
@@ -0,0 +1,20 @@+-- | Some seperate types to solve problems with recursive modules+module Database.RethinkDB.Types where++-- | The type of a RQL expression+-- +-- The type hierarchy has 3 branches:+-- +-- - A read-only sequence: @StreamType False@+-- +-- - A selection (also called a view): @StreamType True@+-- +-- - A value (a JSON object, array or primitive type): @ExprType@++data ExprTypeKind =+    StreamType Bool ValueTypeKind -- ^ When the flag is true, it can be updated or deleted+  | ValueType ValueTypeKind++-- | The types of values+data ValueTypeKind = NumberType | BoolType | ObjectType | ArrayType |+                     StringType | NoneType | OtherValueType
+ LICENSE view
@@ -0,0 +1,15 @@+RethinkDB Language Drivers for Haskell++Copyright 2012 Etienne Laurin++   Licensed under the Apache License, Version 2.0 (the "License");+   you may not use this product except in compliance with the License.+   You may obtain a copy of the License at++       http://www.apache.org/licenses/LICENSE-2.0++   Unless required by applicable law or agreed to in writing, software+   distributed under the License is distributed on an "AS IS" BASIS,+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+   See the License for the specific language governing permissions and+   limitations under the License.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ rethinkdb.cabal view
@@ -0,0 +1,76 @@+name:                rethinkdb+version:             0.1.0.0+synopsis:            RethinkDB client library for haskell+description:         This library is modelled upon the official RethinkDB API for+                     Python and Javascript.+homepage:            http://code.atnnn.com/projects/haskell-rethinkdb+license:             OtherLicense+license-file:        LICENSE+author:              Etienne Laurin+maintainer:          Etienne Laurin <etienne@atnnn.com>+category:            Database+build-type:          Simple+cabal-version:       >=1.8++source-repository head+  type: darcs+  location: http://code.atnnn.com/darcs/rethinkdb++library+  exposed-modules:     Database.RethinkDB,+                       Database.RethinkDB.Driver,+                       Database.RethinkDB.Functions,+                       Database.RethinkDB.Types+  other-modules:       Database.RethinkDB.Internal.Query_Language.Builtin,+                       Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType,+                       Database.RethinkDB.Internal.Query_Language.Builtin.Comparison,+                       Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap,+                       Database.RethinkDB.Internal.Query_Language.Builtin.Filter,+                       Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce,+                       Database.RethinkDB.Internal.Query_Language.Builtin.Map,+                       Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy,+                       Database.RethinkDB.Internal.Query_Language.Builtin.Range,+                       Database.RethinkDB.Internal.Query_Language.Mapping,+                       Database.RethinkDB.Internal.Query_Language.MetaQuery,+                       Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable,+                       Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType,+                       Database.RethinkDB.Internal.Query_Language.Predicate,+                       Database.RethinkDB.Internal.Query_Language.Query,+                       Database.RethinkDB.Internal.Query_Language.Query.QueryType,+                       Database.RethinkDB.Internal.Query_Language.ReadQuery,+                       Database.RethinkDB.Internal.Query_Language.Reduction,+                       Database.RethinkDB.Internal.Query_Language.Response,+                       Database.RethinkDB.Internal.Query_Language.Response.Backtrace,+                       Database.RethinkDB.Internal.Query_Language.Response.StatusCode,+                       Database.RethinkDB.Internal.Query_Language.TableRef,+                       Database.RethinkDB.Internal.Query_Language.Term,+                       Database.RethinkDB.Internal.Query_Language.Term.Call,+                       Database.RethinkDB.Internal.Query_Language.Term.GetByKey,+                       Database.RethinkDB.Internal.Query_Language.Term.If,+                       Database.RethinkDB.Internal.Query_Language.Term.Let,+                       Database.RethinkDB.Internal.Query_Language.Term.Table,+                       Database.RethinkDB.Internal.Query_Language.Term.TermType,+                       Database.RethinkDB.Internal.Query_Language.VarTermTuple,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.Update,+                       Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType,+                       Database.RethinkDB.Internal.Types+  build-depends:       base >= 4.6 && < 5,+                       protocol-buffers >= 2,+                       unordered-containers,+                       text,+                       aeson,+                       bytestring,+                       containers,+                       attoparsec,+                       data-default,+                       network,+                       ghc-prim >= 0.3,+                       mtl