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


-- | Haskell binding for Gremlin graph query language - core data types and tools
--   
--   Haskell binding for <a>Gremlin graph query language</a>. See
--   <a>README.md</a> for detail.
--   
--   This package contains only core data types and tools used commonly by
--   other related packages.
@package greskell-core
@version 1.0.0.3


-- | <b>This module is for advanced use. Most users should just use
--   <a>Data.Greskell.GraphSON</a>.</b>
--   
--   This module defines <a>GValue</a> and exposes its deconstructors.
module Data.Greskell.GraphSON.GValue

-- | An Aeson <a>Value</a> wrapped in <a>GraphSON</a> wrapper type.
--   Basically this type is the Haskell representaiton of a
--   GraphSON-encoded document.
--   
--   This type is used to parse GraphSON documents. See also
--   <a>FromGraphSON</a> class.
newtype GValue
GValue :: GraphSON GValueBody -> GValue
[unGValue] :: GValue -> GraphSON GValueBody

-- | <a>GValue</a> without the top-level <a>GraphSON</a> wrapper.
data GValueBody
GObject :: !KeyMap GValue -> GValueBody
GArray :: !Vector GValue -> GValueBody
GString :: !Text -> GValueBody
GNumber :: !Scientific -> GValueBody
GBool :: !Bool -> GValueBody
GNull :: GValueBody

-- | Create a <a>GValue</a> without "@type" field.
nonTypedGValue :: GValueBody -> GValue

-- | Create a <a>GValue</a> with the given "@type" field.
typedGValue' :: Text -> GValueBody -> GValue

-- | Remove all <a>GraphSON</a> wrappers recursively from <a>GValue</a>.
unwrapAll :: GValue -> Value

-- | Remove the top-level <a>GraphSON</a> wrapper, but leave other wrappers
--   as-is. The remaining wrappers are reconstructed by <a>toJSON</a> to
--   make them into <a>Value</a>.
unwrapOne :: GValue -> Value

-- | Get the <a>GValueBody</a> from <a>GValue</a>.
gValueBody :: GValue -> GValueBody

-- | Get the <a>gsonType</a> field from <a>GValue</a>.
gValueType :: GValue -> Maybe Text
instance GHC.Show.Show Data.Greskell.GraphSON.GValue.GValue
instance GHC.Generics.Generic Data.Greskell.GraphSON.GValue.GValue
instance GHC.Classes.Eq Data.Greskell.GraphSON.GValue.GValue
instance GHC.Show.Show Data.Greskell.GraphSON.GValue.GValueBody
instance GHC.Generics.Generic Data.Greskell.GraphSON.GValue.GValueBody
instance GHC.Classes.Eq Data.Greskell.GraphSON.GValue.GValueBody
instance Data.Hashable.Class.Hashable Data.Greskell.GraphSON.GValue.GValue
instance Data.Hashable.Class.Hashable Data.Greskell.GraphSON.GValue.GValueBody
instance Data.Aeson.Types.FromJSON.FromJSON Data.Greskell.GraphSON.GValue.GValue
instance Data.Aeson.Types.ToJSON.ToJSON Data.Greskell.GraphSON.GValue.GValue
instance Data.Aeson.Types.ToJSON.ToJSON Data.Greskell.GraphSON.GValue.GValueBody


-- | This module defines types for parsing a "g:Map" GraphSON object.
--   Usually users only have to use <a>GMapEntry</a>, because other types
--   are just used internally to implement GraphSON parsers.
module Data.Greskell.GMap

-- | JSON encoding of a map as an array of flattened key-value pairs.
--   
--   <a>ToJSON</a> instance of this type encodes the internal map as an
--   array of keys and values. <a>FromJSON</a> instance of this type parses
--   that flattened map.
--   
--   <ul>
--   <li>type <tt>c</tt>: container type for a map (e.g. <a>Map</a> and
--   <a>HashMap</a>).</li>
--   <li>type <tt>k</tt>: key of the map.</li>
--   <li>type <tt>v</tt>: value of the map.</li>
--   </ul>
newtype FlattenedMap c k v
FlattenedMap :: c k v -> FlattenedMap c k v
[unFlattenedMap] :: FlattenedMap c k v -> c k v

-- | General parser for <a>FlattenedMap</a>.
parseToFlattenedMap :: (IsList (c k v), Item (c k v) ~ (k, v)) => (s -> Parser k) -> (s -> Parser v) -> Vector s -> Parser (FlattenedMap c k v)

-- | Haskell representation of <tt>g:Map</tt> type.
--   
--   GraphSON v1 and v2 encode Java <tt>Map</tt> type as a JSON Object,
--   while GraphSON v3 encodes it as an array of flattened keys and values
--   (like <a>FlattenedMap</a>.) <a>GMap</a> type handles both encoding
--   schemes.
--   
--   <ul>
--   <li>type <tt>c</tt>: container type for a map (e.g. <a>Map</a> and
--   <a>HashMap</a>).</li>
--   <li>type <tt>k</tt>: key of the map.</li>
--   <li>type <tt>v</tt>: value of the map.</li>
--   </ul>
data GMap c k v
GMap :: !Bool -> !c k v -> GMap c k v

-- | If <a>True</a>, the map is encoded as an array. If <a>False</a>, it's
--   encoded as a JSON Object.
[gmapFlat] :: GMap c k v -> !Bool

-- | Map implementation.
[gmapValue] :: GMap c k v -> !c k v

-- | Get the map implementation from <a>GMap</a>.
unGMap :: GMap c k v -> c k v

-- | Create <a>GMap</a> that has the single <a>GMapEntry</a>.
singleton :: (IsList (c k v), Item (c k v) ~ (k, v)) => GMapEntry k v -> GMap c k v

-- | Deconstruct <a>GMap</a> into a list of <a>GMapEntry</a>s.
toList :: (IsList (c k v), Item (c k v) ~ (k, v)) => GMap c k v -> [GMapEntry k v]

-- | General parser for <a>GMap</a>.
parseToGMap :: (IsList (c k v), Item (c k v) ~ (k, v)) => (s -> Parser k) -> (s -> Parser v) -> (KeyMap s -> Parser (c k v)) -> Either (KeyMap s) (Vector s) -> Parser (GMap c k v)

-- | Haskell representation of <tt>Map.Entry</tt> type.
--   
--   Basically GraphSON encodes Java's <tt>Map.Entry</tt> type as if it
--   were a <tt>Map</tt> with a single entry. Thus its encoded form is
--   either a JSON object or a flattened key-values, as explained in
--   <a>GMap</a>.
--   
--   In old versions of TinkerPop, <tt>Map.Entry</tt> is encoded as a JSON
--   object with "key" and "value" fields. <a>FromJSON</a> instance of
--   <a>GMapEntry</a> supports this format as well, but <a>ToJSON</a>
--   instance doesn't support it.
data GMapEntry k v
GMapEntry :: !Bool -> !k -> !v -> GMapEntry k v
[gmapEntryFlat] :: GMapEntry k v -> !Bool
[gmapEntryKey] :: GMapEntry k v -> !k
[gmapEntryValue] :: GMapEntry k v -> !v

-- | Get the key-value pair from <a>GMapEntry</a>.
unGMapEntry :: GMapEntry k v -> (k, v)

-- | General parser for <a>GMapEntry</a>.
parseToGMapEntry :: FromJSONKey k => (s -> Parser k) -> (s -> Parser v) -> Either (KeyMap s) (Vector s) -> Parser (GMapEntry k v)

-- | Examples of using this module. See the source. The <a>fst</a> of the
--   output is the testee, while the <a>snd</a> is the expectation.
examples :: [(String, String)]
instance Data.Traversable.Traversable (c k) => Data.Traversable.Traversable (Data.Greskell.GMap.FlattenedMap c k)
instance GHC.Show.Show (c k v) => GHC.Show.Show (Data.Greskell.GMap.FlattenedMap c k v)
instance GHC.Classes.Ord (c k v) => GHC.Classes.Ord (Data.Greskell.GMap.FlattenedMap c k v)
instance GHC.Base.Functor (c k) => GHC.Base.Functor (Data.Greskell.GMap.FlattenedMap c k)
instance Data.Foldable.Foldable (c k) => Data.Foldable.Foldable (Data.Greskell.GMap.FlattenedMap c k)
instance GHC.Classes.Eq (c k v) => GHC.Classes.Eq (Data.Greskell.GMap.FlattenedMap c k v)
instance Data.Traversable.Traversable (c k) => Data.Traversable.Traversable (Data.Greskell.GMap.GMap c k)
instance GHC.Show.Show (c k v) => GHC.Show.Show (Data.Greskell.GMap.GMap c k v)
instance GHC.Base.Functor (c k) => GHC.Base.Functor (Data.Greskell.GMap.GMap c k)
instance Data.Foldable.Foldable (c k) => Data.Foldable.Foldable (Data.Greskell.GMap.GMap c k)
instance GHC.Classes.Eq (c k v) => GHC.Classes.Eq (Data.Greskell.GMap.GMap c k v)
instance Data.Traversable.Traversable (Data.Greskell.GMap.GMapEntry k)
instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Greskell.GMap.GMapEntry k v)
instance (GHC.Classes.Ord k, GHC.Classes.Ord v) => GHC.Classes.Ord (Data.Greskell.GMap.GMapEntry k v)
instance GHC.Base.Functor (Data.Greskell.GMap.GMapEntry k)
instance Data.Foldable.Foldable (Data.Greskell.GMap.GMapEntry k)
instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Data.Greskell.GMap.GMapEntry k v)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.GMap.GMapEntry k v)
instance (Data.Aeson.Types.FromJSON.FromJSON k, Data.Aeson.Types.FromJSON.FromJSONKey k, Data.Aeson.Types.FromJSON.FromJSON v) => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.GMap.GMapEntry k v)
instance (Data.Aeson.Types.ToJSON.ToJSON k, Data.Aeson.Types.ToJSON.ToJSONKey k, GHC.Classes.Ord k, Data.Aeson.Types.ToJSON.ToJSON v) => Data.Aeson.Types.ToJSON.ToJSON (Data.Greskell.GMap.GMapEntry k v)
instance (Data.Aeson.Types.FromJSON.FromJSON k, Data.Aeson.Types.FromJSON.FromJSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v), Data.Aeson.Types.FromJSON.FromJSON (c k v)) => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.GMap.GMap c k v)
instance (Data.Aeson.Types.ToJSON.ToJSON k, Data.Aeson.Types.ToJSON.ToJSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v), Data.Aeson.Types.ToJSON.ToJSON (c k v)) => Data.Aeson.Types.ToJSON.ToJSON (Data.Greskell.GMap.GMap c k v)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.GMap.GMap c k v)
instance (Data.Aeson.Types.FromJSON.FromJSON k, Data.Aeson.Types.FromJSON.FromJSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v)) => Data.Aeson.Types.FromJSON.FromJSON (Data.Greskell.GMap.FlattenedMap c k v)
instance (Data.Aeson.Types.ToJSON.ToJSON k, Data.Aeson.Types.ToJSON.ToJSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v)) => Data.Aeson.Types.ToJSON.ToJSON (Data.Greskell.GMap.FlattenedMap c k v)
instance Data.Greskell.GraphSON.GraphSONTyped.GraphSONTyped (Data.Greskell.GMap.FlattenedMap c k v)


module Data.Greskell.GraphSON

-- | Wrapper for "typed JSON object" introduced in GraphSON version 2. See
--   <a>http://tinkerpop.apache.org/docs/current/dev/io/#graphson</a>
--   
--   This data type is useful for encoding/decoding GraphSON text.
--   
--   Note that encoding of the "g:Map" type is inconsistent between
--   GraphSON v1 and v2, v3. To handle the encoding, use
--   <a>Data.Greskell.GMap</a>.
data GraphSON v
GraphSON :: Maybe Text -> v -> GraphSON v

-- | Type ID, corresponding to <tt>@type</tt> field.
[gsonType] :: GraphSON v -> Maybe Text

-- | Value, correspoding to <tt>@value</tt> field.
[gsonValue] :: GraphSON v -> v

-- | Types that have an intrinsic type ID for <tt>gsonType</tt> field.
class GraphSONTyped a

-- | Type ID for <tt>gsonType</tt>.
gsonTypeFor :: GraphSONTyped a => a -> Text

-- | Create a <a>GraphSON</a> without <a>gsonType</a>.
nonTypedGraphSON :: v -> GraphSON v

-- | Create a <a>GraphSON</a> with its type ID.
typedGraphSON :: GraphSONTyped v => v -> GraphSON v

-- | Create a <a>GraphSON</a> with the given type ID.
typedGraphSON' :: Text -> v -> GraphSON v

-- | Parse <tt>GraphSON v</tt>, but it checks <a>gsonType</a>. If
--   <a>gsonType</a> is <a>Nothing</a> or it's not equal to
--   <a>gsonTypeFor</a>, the <a>Parser</a> fails.
parseTypedGraphSON :: (GraphSONTyped v, FromJSON v) => Value -> Parser (GraphSON v)

-- | An Aeson <a>Value</a> wrapped in <a>GraphSON</a> wrapper type.
--   Basically this type is the Haskell representaiton of a
--   GraphSON-encoded document.
--   
--   This type is used to parse GraphSON documents. See also
--   <a>FromGraphSON</a> class.
data GValue

-- | <a>GValue</a> without the top-level <a>GraphSON</a> wrapper.
data GValueBody
GObject :: !KeyMap GValue -> GValueBody
GArray :: !Vector GValue -> GValueBody
GString :: !Text -> GValueBody
GNumber :: !Scientific -> GValueBody
GBool :: !Bool -> GValueBody
GNull :: GValueBody

-- | Create a <a>GValue</a> without "@type" field.
nonTypedGValue :: GValueBody -> GValue

-- | Create a <a>GValue</a> with the given "@type" field.
typedGValue' :: Text -> GValueBody -> GValue

-- | Types that can be constructed from <a>GValue</a>. This is analogous to
--   <a>FromJSON</a> class.
--   
--   Instances of basic types are implemented based on the following rule.
--   
--   <ul>
--   <li>Simple scalar types (e.g. <a>Int</a> and <a>Text</a>): use
--   <a>parseUnwrapAll</a>.</li>
--   <li>List-like types (e.g. <tt>[]</tt>, <a>Vector</a> and <a>Set</a>):
--   use <a>parseUnwrapList</a>.</li>
--   <li>Map-like types (e.g. <a>HashMap</a> and <a>Map</a>): parse into
--   <a>GMap</a> first, then unwrap the <a>GMap</a> wrapper. That way, all
--   versions of GraphSON formats are handled properly.</li>
--   <li>Trivial wrapper types (e.g. <a>Identity</a>): just parse the item
--   inside.</li>
--   <li>Other types: see the individual instance documentation.</li>
--   </ul>
--   
--   Note that <a>Char</a> does not have <a>FromGraphSON</a> instance. This
--   is intentional. As stated in the document of <a>AsIterator</a>, using
--   <a>Value</a> in greskell is an error in most cases. To prevent you
--   from using <a>Value</a>, <a>Char</a> (and thus <a>Value</a>) don't
--   have <a>FromGraphSON</a> instances.
class FromGraphSON a
parseGraphSON :: FromGraphSON a => GValue -> Parser a

-- | A JSON parser. N.B. This might not fit your usual understanding of
--   "parser". Instead you might like to think of <a>Parser</a> as a "parse
--   result", i.e. a parser to which the input has already been applied.
data () => Parser a

-- | Parse <a>GValue</a> into <a>FromGraphSON</a>.
parseEither :: FromGraphSON a => GValue -> Either String a

-- | Unwrap the given <a>GValue</a> with <a>unwrapAll</a>, and just parse
--   the result with <a>parseJSON</a>.
--   
--   Useful to implement <a>FromGraphSON</a> instances for scalar types.
parseUnwrapAll :: FromJSON a => GValue -> Parser a

-- | Extract <a>GArray</a> from the given <a>GValue</a>, parse the items in
--   the array, and gather them by <a>fromList</a>.
--   
--   Useful to implement <a>FromGraphSON</a> instances for <a>IsList</a>
--   types.
parseUnwrapList :: (IsList a, i ~ Item a, FromGraphSON i) => GValue -> Parser a

-- | Like Aeson's <a>.:</a>, but for <a>FromGraphSON</a>.
(.:) :: FromGraphSON a => KeyMap GValue -> Key -> Parser a

-- | Implementation of <a>parseJSON</a> based on <a>parseGraphSON</a>. The
--   input <a>Value</a> is first converted to <a>GValue</a>, and it's
--   parsed to the output type.
parseJSONViaGValue :: FromGraphSON a => Value -> Parser a

-- | Examples of using this module. See the source. The <a>fst</a> of the
--   output is the testee, while the <a>snd</a> is the expectation.
examples :: [(String, String)]
instance Data.Greskell.GraphSON.FromGraphSON Data.Greskell.GraphSON.GValue.GValue
instance Data.Greskell.GraphSON.FromGraphSON GHC.Types.Int
instance Data.Greskell.GraphSON.FromGraphSON Data.Text.Internal.Text
instance Data.Greskell.GraphSON.FromGraphSON Data.Text.Internal.Lazy.Text
instance Data.Greskell.GraphSON.FromGraphSON GHC.Types.Bool
instance Data.Greskell.GraphSON.FromGraphSON GHC.Types.Double
instance Data.Greskell.GraphSON.FromGraphSON GHC.Types.Float
instance Data.Greskell.GraphSON.FromGraphSON GHC.Int.Int8
instance Data.Greskell.GraphSON.FromGraphSON GHC.Int.Int16
instance Data.Greskell.GraphSON.FromGraphSON GHC.Int.Int32
instance Data.Greskell.GraphSON.FromGraphSON GHC.Int.Int64
instance Data.Greskell.GraphSON.FromGraphSON GHC.Num.Integer.Integer
instance Data.Greskell.GraphSON.FromGraphSON GHC.Num.Natural.Natural
instance (Data.Aeson.Types.FromJSON.FromJSON a, GHC.Real.Integral a) => Data.Greskell.GraphSON.FromGraphSON (GHC.Real.Ratio a)
instance Data.Greskell.GraphSON.FromGraphSON GHC.Types.Word
instance Data.Greskell.GraphSON.FromGraphSON GHC.Word.Word8
instance Data.Greskell.GraphSON.FromGraphSON GHC.Word.Word16
instance Data.Greskell.GraphSON.FromGraphSON GHC.Word.Word32
instance Data.Greskell.GraphSON.FromGraphSON GHC.Word.Word64
instance Data.Greskell.GraphSON.FromGraphSON Data.Scientific.Scientific
instance Data.Greskell.GraphSON.FromGraphSON Data.IntSet.Internal.IntSet
instance Data.Greskell.GraphSON.FromGraphSON Data.Aeson.Key.Key
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON [a]
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Vector.Vector a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Sequence.Internal.Seq a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (GHC.Base.NonEmpty a)
instance (Data.Greskell.GraphSON.FromGraphSON a, GHC.Classes.Ord a) => Data.Greskell.GraphSON.FromGraphSON (Data.Set.Internal.Set a)
instance (Data.Greskell.GraphSON.FromGraphSON a, GHC.Classes.Eq a, Data.Hashable.Class.Hashable a) => Data.Greskell.GraphSON.FromGraphSON (Data.HashSet.Internal.HashSet a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Functor.Identity.Identity a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Min a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Max a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.First a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Last a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.WrappedMonoid a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Internal.Dual a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Internal.Sum a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Semigroup.Internal.Product a)
instance Data.Greskell.GraphSON.FromGraphSON Data.Semigroup.Internal.All
instance Data.Greskell.GraphSON.FromGraphSON Data.Semigroup.Internal.Any
instance (Data.Greskell.GraphSON.FromGraphSON k, Data.Greskell.GraphSON.FromGraphSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v)) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.GMap.FlattenedMap c k v)
instance (Data.Greskell.GraphSON.FromGraphSON k, Data.Greskell.GraphSON.FromGraphSON v, GHC.IsList.IsList (c k v), GHC.IsList.Item (c k v) GHC.Types.~ (k, v), Data.Traversable.Traversable (c k), Data.Aeson.Types.FromJSON.FromJSON (c k Data.Greskell.GraphSON.GValue.GValue)) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.GMap.GMap c k v)
instance (Data.Greskell.GraphSON.FromGraphSON k, Data.Greskell.GraphSON.FromGraphSON v, Data.Aeson.Types.FromJSON.FromJSONKey k) => Data.Greskell.GraphSON.FromGraphSON (Data.Greskell.GMap.GMapEntry k v)
instance (Data.Greskell.GraphSON.FromGraphSON v, GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Data.Aeson.Types.FromJSON.FromJSONKey k, Data.Greskell.GraphSON.FromGraphSON k) => Data.Greskell.GraphSON.FromGraphSON (Data.HashMap.Internal.HashMap k v)
instance (Data.Greskell.GraphSON.FromGraphSON v, GHC.Classes.Ord k, Data.Aeson.Types.FromJSON.FromJSONKey k, Data.Greskell.GraphSON.FromGraphSON k) => Data.Greskell.GraphSON.FromGraphSON (Data.Map.Internal.Map k v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.GraphSON.FromGraphSON (Data.IntMap.Internal.IntMap v)
instance Data.Greskell.GraphSON.FromGraphSON v => Data.Greskell.GraphSON.FromGraphSON (Data.Aeson.KeyMap.KeyMap v)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (GHC.Maybe.Maybe a)
instance (Data.Greskell.GraphSON.FromGraphSON a, Data.Greskell.GraphSON.FromGraphSON b) => Data.Greskell.GraphSON.FromGraphSON (Data.Either.Either a b)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Monoid.First a)
instance Data.Greskell.GraphSON.FromGraphSON a => Data.Greskell.GraphSON.FromGraphSON (Data.Monoid.Last a)
instance Data.Greskell.GraphSON.FromGraphSON Data.Aeson.Types.Internal.Value
instance Data.Greskell.GraphSON.FromGraphSON Data.UUID.Types.Internal.UUID
instance Data.Greskell.GraphSON.FromGraphSON ()


module Data.Greskell.AsIterator

-- | Types that are converted to an iterator by
--   <tt>org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils.asIterator</tt>
--   method. In fact, that method can convert any type to an iterator, but
--   greskell limits types to which the conversion is applicable.
--   
--   Associated with this type-class is <a>IteratorItem</a>.
--   <a>IteratorItem</a> type family is association of type <tt>a</tt> and
--   the type of its item when type <tt>a</tt> is converted to an iterator.
--   
--   <a>IteratorItem</a> rule of thumb:
--   
--   <ul>
--   <li><tt>Iterator</tt> and <tt>Iterable</tt> types like <tt>List</tt>,
--   <tt>Stream</tt> and <tt>GraphTraversal</tt> are converted to their
--   element types.</li>
--   <li><tt>Map</tt> type is converted to its <tt>Map.Entry</tt>. In
--   greskell, <tt>Map.Entry</tt> is expressed as <a>GMapEntry</a>.</li>
--   <li>Other types are converted to themselves.</li>
--   </ul>
--   
--   Caveat:
--   
--   <ul>
--   <li>Because Haskell's <a>String</a> is <tt>[Char]</tt>,
--   <tt>IteratorItem String</tt> returns <a>Char</a>, which is incorrect.
--   Use <a>Text</a> if you want to deal with <tt>String</tt>s in
--   Gremlin.</li>
--   </ul>
class AsIterator a where {
    type IteratorItem a;
}
instance Data.Greskell.AsIterator.AsIterator ()
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Int
instance Data.Greskell.AsIterator.AsIterator Data.Text.Internal.Text
instance Data.Greskell.AsIterator.AsIterator Data.Text.Internal.Lazy.Text
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Bool
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Char
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Double
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Float
instance Data.Greskell.AsIterator.AsIterator GHC.Int.Int8
instance Data.Greskell.AsIterator.AsIterator GHC.Int.Int16
instance Data.Greskell.AsIterator.AsIterator GHC.Int.Int32
instance Data.Greskell.AsIterator.AsIterator GHC.Int.Int64
instance Data.Greskell.AsIterator.AsIterator GHC.Num.Integer.Integer
instance Data.Greskell.AsIterator.AsIterator GHC.Num.Natural.Natural
instance GHC.Real.Integral a => Data.Greskell.AsIterator.AsIterator (GHC.Real.Ratio a)
instance Data.Greskell.AsIterator.AsIterator GHC.Types.Word
instance Data.Greskell.AsIterator.AsIterator GHC.Word.Word8
instance Data.Greskell.AsIterator.AsIterator GHC.Word.Word16
instance Data.Greskell.AsIterator.AsIterator GHC.Word.Word32
instance Data.Greskell.AsIterator.AsIterator GHC.Word.Word64
instance Data.Greskell.AsIterator.AsIterator Data.Scientific.Scientific
instance Data.Greskell.AsIterator.AsIterator [a]
instance Data.Greskell.AsIterator.AsIterator (Data.Vector.Vector a)
instance Data.Greskell.AsIterator.AsIterator (Data.HashSet.Internal.HashSet a)
instance Data.Greskell.AsIterator.AsIterator (Data.Sequence.Internal.Seq a)
instance Data.Greskell.AsIterator.AsIterator (Data.Set.Internal.Set a)
instance Data.Greskell.AsIterator.AsIterator Data.IntSet.Internal.IntSet
instance Data.Greskell.AsIterator.AsIterator (GHC.Base.NonEmpty a)
instance Data.Greskell.AsIterator.AsIterator (Data.Greskell.GMap.GMap c k v)
instance Data.Greskell.AsIterator.AsIterator (Data.Greskell.GMap.GMapEntry k v)
instance Data.Greskell.AsIterator.AsIterator (Data.HashMap.Internal.HashMap k v)
instance Data.Greskell.AsIterator.AsIterator (Data.Map.Internal.Map k v)
instance Data.Greskell.AsIterator.AsIterator (Data.IntMap.Internal.IntMap v)
instance Data.Greskell.AsIterator.AsIterator a => Data.Greskell.AsIterator.AsIterator (GHC.Maybe.Maybe a)


module Data.Greskell.Greskell

-- | Gremlin expression of type <tt>a</tt>.
--   
--   <a>Greskell</a> is essentially just a piece of Gremlin script with a
--   phantom type. The type <tt>a</tt> represents the type of data that the
--   script is supposed to evaluate to.
--   
--   <a>Eq</a> and <a>Ord</a> instances compare Gremlin scripts, NOT the
--   values they evaluate to.
data Greskell a

-- | Something that can convert to <a>Greskell</a>.
class ToGreskell a where {
    
    -- | type of return value by Greskell.
    type GreskellReturn a;
}
toGreskell :: ToGreskell a => a -> Greskell (GreskellReturn a)

-- | Create a readable Gremlin script from <a>Greskell</a>.
toGremlin :: ToGreskell a => a -> Text

-- | Same as <a>toGremlin</a> except that this returns lazy <a>Text</a>.
toGremlinLazy :: ToGreskell a => a -> Text

-- | Create a String literal in Gremlin script. The content is
--   automatically escaped.
string :: Text -> Greskell Text

-- | Boolean <tt>true</tt> literal.
true :: Greskell Bool

-- | Boolean <tt>false</tt> literal.
false :: Greskell Bool

-- | List literal.
list :: [Greskell a] -> Greskell [a]

-- | Make a list with a single object. Useful to prevent the Gremlin Server
--   from automatically iterating the result object.
single :: Greskell a -> Greskell [a]

-- | Arbitrary precision number literal, like "123e8".
number :: Scientific -> Greskell Scientific

-- | Aeson <a>Value</a> literal.
--   
--   Note that <a>Number</a> does not distinguish integers from
--   floating-point numbers, so <a>value</a> function may format an integer
--   as a floating-point number. To ensure formatting as integers, use
--   <a>valueInt</a>.
value :: Value -> Greskell Value

-- | Integer literal as <a>Value</a> type.
valueInt :: Integral a => a -> Greskell Value

-- | <a>Value</a> literal as <a>GValue</a> type.
gvalue :: Value -> Greskell GValue

-- | Integer literal as <a>GValue</a> type.
gvalueInt :: Integral a => a -> Greskell GValue

-- | Unsafely create a <a>Greskell</a> of arbitrary type. The given Gremlin
--   script is printed as-is.
unsafeGreskell :: Text -> Greskell a

-- | Same as <a>unsafeGreskell</a>, but it takes lazy <a>Text</a>.
unsafeGreskellLazy :: Text -> Greskell a

-- | Unsafely create a <a>Greskell</a> that calls the given function with
--   the given arguments.
unsafeFunCall :: Text -> [Text] -> Greskell a

-- | Unsafely create a <a>Greskell</a> that calls the given object method
--   call with the given target and arguments.
unsafeMethodCall :: Greskell a -> Text -> [Text] -> Greskell b

-- | Examples of using this module. See the source. The <a>fst</a> of the
--   output is the testee, while the <a>snd</a> is the expectation.
examples :: [(Text, Text)]
instance GHC.Show.Show (Data.Greskell.Greskell.Greskell a)
instance GHC.Classes.Ord (Data.Greskell.Greskell.Greskell a)
instance GHC.Classes.Eq (Data.Greskell.Greskell.Greskell a)
instance Data.Greskell.Greskell.ToGreskell (Data.Greskell.Greskell.Greskell a)
instance Data.String.IsString a => Data.String.IsString (Data.Greskell.Greskell.Greskell a)
instance GHC.Base.Functor Data.Greskell.Greskell.Greskell
instance GHC.Num.Num a => GHC.Num.Num (Data.Greskell.Greskell.Greskell a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Data.Greskell.Greskell.Greskell a)
instance Data.String.IsString a => GHC.Base.Semigroup (Data.Greskell.Greskell.Greskell a)
instance Data.String.IsString a => GHC.Base.Monoid (Data.Greskell.Greskell.Greskell a)