-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell bindings for the neo4j "cypher" query language
--   
--   haskell-cypher makes it easy to send cypher commands to neo4j servers
--   over their REST API. Additionally, it allows users to parse haskell
--   datatypes from <a>cypher</a> queries.
@package cypher
@version 0.2

module Data.Default.TH
deriveDefault :: Name -> Q [Dec]

module Data.Aeson.TH.Smart

-- | Generates both <a>ToJSON</a> and <a>FromJSON</a> instance declarations
--   for the given data type.
--   
--   This is a convienience function which is equivalent to calling both
--   <a>deriveToJSON</a> and <a>deriveFromJSON</a>.
deriveJSON :: (String -> String) -> Name -> Q [Dec]

-- | Generates a <a>ToJSON</a> instance declaration for the given data
--   type.
--   
--   Example:
--   
--   <pre>
--   data Foo = Foo <tt>Char</tt> <tt>Int</tt>
--   $(<a>deriveToJSON</a> <a>id</a> ''Foo)
--   </pre>
--   
--   This will splice in the following code:
--   
--   <pre>
--   instance <a>ToJSON</a> Foo where
--        <a>toJSON</a> =
--            value -&gt; case value of
--                        Foo arg1 arg2 -&gt; <a>Array</a> $ <a>create</a> $ do
--                          mv &lt;- <a>unsafeNew</a> 2
--                          <a>unsafeWrite</a> mv 0 (<a>toJSON</a> arg1)
--                          <a>unsafeWrite</a> mv 1 (<a>toJSON</a> arg2)
--                          return mv
--   </pre>
deriveToJSON :: (String -> String) -> Name -> Q [Dec]

-- | Generates a <a>FromJSON</a> instance declaration for the given data
--   type.
--   
--   Example:
--   
--   <pre>
--   data Foo = Foo Char Int
--   $(<a>deriveFromJSON</a> id ''Foo)
--   </pre>
--   
--   This will splice in the following code:
--   
--   <pre>
--   instance <a>FromJSON</a> Foo where
--       <a>parseJSON</a> =
--           value -&gt; case value of
--                       <a>Array</a> arr -&gt;
--                         if (V.length arr == 2)
--                         then Foo &lt;$&gt; <a>parseJSON</a> (arr <a>unsafeIndex</a> 0)
--                                  &lt;*&gt; <a>parseJSON</a> (arr <a>unsafeIndex</a> 1)
--                         else fail "&lt;error message&gt;"
--                       other -&gt; fail "&lt;error message&gt;"
--   </pre>
deriveFromJSON :: (String -> String) -> Name -> Q [Dec]

-- | Generates a lambda expression which encodes the given data type as
--   JSON.
--   
--   Example:
--   
--   <pre>
--   data Foo = Foo Int
--   </pre>
--   
--   <pre>
--   encodeFoo :: Foo -&gt; <a>Value</a>
--   encodeFoo = $(<a>mkToJSON</a> id ''Foo)
--   </pre>
--   
--   This will splice in the following code:
--   
--   <pre>
--   value -&gt; case value of Foo arg1 -&gt; <a>toJSON</a> arg1
--   </pre>
mkToJSON :: (String -> String) -> Name -> Q Exp

-- | Generates a lambda expression which parses the JSON encoding of the
--   given data type.
--   
--   Example:
--   
--   <pre>
--   data Foo = Foo <tt>Int</tt>
--   </pre>
--   
--   <pre>
--   parseFoo :: <a>Value</a> -&gt; <a>Parser</a> Foo
--   parseFoo = $(<a>mkParseJSON</a> id ''Foo)
--   </pre>
--   
--   This will splice in the following code:
--   
--   <pre>
--   \value -&gt; case value of arg -&gt; Foo &lt;$&gt; <a>parseJSON</a> arg
--   </pre>
mkParseJSON :: (String -> String) -> Name -> Q Exp

module Database.Cypher.Lucene

-- | Convert an object to a Lucene query encoded as an <a>ByteString</a>.
luceneEncode :: ToJSON a => a -> ByteString

module Database.Cypher

-- | All interaction with Neo4j is done through the Cypher monad. Use
--   <a>cypher</a> to add a query to the monad.
data Cypher a

-- | A neo4j node or edge
data Entity a

-- | Raw result data returned by Neo4j. Only use this if you care about
--   column headers.
data CypherResult a
CypherResult :: [Text] -> a -> CypherResult a
rescolumns :: CypherResult a -> [Text]
resdata :: CypherResult a -> a

-- | Execute some number of cypher queries
runCypher :: Cypher a -> Hostname -> Port -> IO a

-- | Perform a cypher query
cypher :: FromCypher a => Text -> Value -> Cypher a

-- | An error in handling a Cypher query, either in communicating with the
--   server or parsing the result
data CypherException
CypherServerException :: Status -> ResponseHeaders -> ByteString -> CypherException
CypherClientParseException :: ByteString -> CypherException
type Hostname = ByteString
type Port = Int

-- | OneTuple is the singleton tuple data type.
data OneTuple a :: * -> *

-- | singleton tuple constructor
OneTuple :: a -> OneTuple a
instance Typeable CypherException
instance Show CypherException
instance FromJSON a => FromCypher (Maybe a)
instance (FromJSON a, FromJSON b, FromJSON c) => FromCypher (a, b, c)
instance (FromJSON a, FromJSON b) => FromCypher (a, b)
instance FromJSON a => FromCypher (OneTuple a)
instance FromJSON a => FromCypher [a]
instance FromJSON a => FromCypher (CypherResult a)
instance FromCypher ()
instance Monad Cypher
instance Exception CypherException
instance FromJSON CypherRequest
instance ToJSON CypherRequest
instance FromJSON a0 => FromJSON (CypherResult a0)
instance ToJSON a0 => ToJSON (CypherResult a0)
instance Show a => Show (CypherResult a)
instance Eq a => Eq (CypherResult a)
instance Show CypherRequest
instance Eq CypherRequest
instance Show a => Show (Entity a)
instance Eq a => Eq (Entity a)
instance ToJSON a => ToJSON (OneTuple a)
instance FromJSON a => FromJSON (OneTuple a)
instance ToJSON (Entity a)
instance FromJSON a => FromJSON (Entity a)