{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
module Data.Greskell.Gremlin
(
Predicate (..)
, PredicateA (..)
, P
, PLike (..)
, pNot
, pEq
, pNeq
, pLt
, pLte
, pGt
, pGte
, pInside
, pOutside
, pBetween
, pWithin
, pWithout
, Comparator (..)
, ComparatorA (..)
, Order
, oDesc
, oAsc
, oDecr
, oIncr
, oShuffle
, examples
) where
import Data.Aeson (Value)
import Data.Greskell.GraphSON (GraphSONTyped (..))
import Data.Greskell.Greskell (Greskell, ToGreskell, string, toGremlin, toGremlinLazy,
unsafeFunCall, unsafeGreskellLazy, unsafeMethodCall)
import Data.Monoid ((<>))
import Data.Text (Text)
class Predicate p where
type PredicateArg p
pAnd :: Greskell p -> Greskell p -> Greskell p
pAnd Greskell p
p1 Greskell p
p2 = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell p
p1 Text
"and" [forall a. ToGreskell a => a -> Text
toGremlin Greskell p
p2]
pOr :: Greskell p -> Greskell p -> Greskell p
pOr Greskell p
o1 Greskell p
o2 = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell p
o1 Text
"or" [forall a. ToGreskell a => a -> Text
toGremlin Greskell p
o2]
pTest :: Greskell p -> Greskell (PredicateArg p) -> Greskell Bool
pTest Greskell p
p Greskell (PredicateArg p)
arg = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell p
p Text
"test" [forall a. ToGreskell a => a -> Text
toGremlin Greskell (PredicateArg p)
arg]
pNegate :: Greskell p -> Greskell p
pNegate Greskell p
p = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell p
p Text
"negate" []
newtype PredicateA a
= PredicateA { forall a. PredicateA a -> a -> Bool
unPredicateA :: a -> Bool }
instance Predicate (PredicateA a) where
type PredicateArg (PredicateA a) = a
data P a
instance Predicate (P a) where
type PredicateArg (P a) = a
instance GraphSONTyped (P a) where
gsonTypeFor :: P a -> Text
gsonTypeFor P a
_ = Text
"g:P"
class (ToGreskell (PParameter p)) => PLike p where
type PParameter p
instance PLike (P a) where
type PParameter (P a) = Greskell a
pNot :: PLike p => Greskell p -> Greskell p
pNot :: forall p. PLike p => Greskell p -> Greskell p
pNot Greskell p
a = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.not" [forall a. ToGreskell a => a -> Text
toGremlin Greskell p
a]
pEq :: PLike p => PParameter p -> Greskell p
pEq :: forall p. PLike p => PParameter p -> Greskell p
pEq PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.eq" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pNeq :: PLike p => PParameter p -> Greskell p
pNeq :: forall p. PLike p => PParameter p -> Greskell p
pNeq PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.neq" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pLt :: PLike p => PParameter p -> Greskell p
pLt :: forall p. PLike p => PParameter p -> Greskell p
pLt PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.lt" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pLte :: PLike p => PParameter p -> Greskell p
pLte :: forall p. PLike p => PParameter p -> Greskell p
pLte PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.lte" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pGt :: PLike p => PParameter p -> Greskell p
pGt :: forall p. PLike p => PParameter p -> Greskell p
pGt PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.gt" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pGte :: PLike p => PParameter p -> Greskell p
pGte :: forall p. PLike p => PParameter p -> Greskell p
pGte PParameter p
arg = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.gte" [forall a. ToGreskell a => a -> Text
toGremlin PParameter p
arg]
pInside :: PLike p => PParameter p -> PParameter p -> Greskell p
pInside :: forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pInside PParameter p
a PParameter p
b = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.inside" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin [PParameter p
a, PParameter p
b]
pOutside :: PLike p => PParameter p -> PParameter p -> Greskell p
pOutside :: forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pOutside PParameter p
a PParameter p
b = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.outside" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin [PParameter p
a, PParameter p
b]
pBetween :: PLike p => PParameter p -> PParameter p -> Greskell p
pBetween :: forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pBetween PParameter p
a PParameter p
b = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.between" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin [PParameter p
a, PParameter p
b]
pWithin :: PLike p => [PParameter p] -> Greskell p
pWithin :: forall p. PLike p => [PParameter p] -> Greskell p
pWithin = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.within" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin
pWithout :: PLike p => [PParameter p] -> Greskell p
pWithout :: forall p. PLike p => [PParameter p] -> Greskell p
pWithout = forall a. Text -> [Text] -> Greskell a
unsafeFunCall Text
"P.without" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin
class Comparator c where
type CompareArg c
cCompare :: Greskell c -> Greskell (CompareArg c) -> Greskell (CompareArg c) -> Greskell Int
cCompare Greskell c
cmp Greskell (CompareArg c)
a Greskell (CompareArg c)
b = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell c
cmp Text
"compare" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. ToGreskell a => a -> Text
toGremlin [Greskell (CompareArg c)
a, Greskell (CompareArg c)
b]
cReversed :: Greskell c -> Greskell c
cReversed Greskell c
cmp = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell c
cmp Text
"reversed" []
cThenComparing :: Greskell c -> Greskell c -> Greskell c
cThenComparing Greskell c
cmp1 Greskell c
cmp2 = forall a b. Greskell a -> Text -> [Text] -> Greskell b
unsafeMethodCall Greskell c
cmp1 Text
"thenComparing" [forall a. ToGreskell a => a -> Text
toGremlin Greskell c
cmp2]
newtype ComparatorA a
= ComparatorA { forall a. ComparatorA a -> a -> a -> Int
unComparatorA :: a -> a -> Int }
instance Comparator (ComparatorA a) where
type CompareArg (ComparatorA a) = a
data Order a
instance Comparator (Order a) where
type CompareArg (Order a) = a
instance GraphSONTyped (Order a) where
gsonTypeFor :: Order a -> Text
gsonTypeFor Order a
_ = Text
"g:Order"
oDesc :: Greskell (Order a)
oDesc :: forall a. Greskell (Order a)
oDesc = forall a. Text -> Greskell a
unsafeGreskellLazy Text
"Order.desc"
oAsc :: Greskell (Order a)
oAsc :: forall a. Greskell (Order a)
oAsc = forall a. Text -> Greskell a
unsafeGreskellLazy Text
"Order.asc"
oDecr :: Greskell (Order a)
oDecr :: forall a. Greskell (Order a)
oDecr = forall a. Text -> Greskell a
unsafeGreskellLazy Text
"Order.decr"
oIncr :: Greskell (Order a)
oIncr :: forall a. Greskell (Order a)
oIncr = forall a. Text -> Greskell a
unsafeGreskellLazy Text
"Order.incr"
oShuffle :: Greskell (Order a)
oShuffle :: forall a. Greskell (Order a)
oShuffle = forall a. Text -> Greskell a
unsafeGreskellLazy Text
"Order.shuffle"
examples :: [(Text, Text)]
examples :: [(Text, Text)]
examples =
[ (forall a. ToGreskell a => a -> Text
toGremlin (forall p. PLike p => Greskell p -> Greskell p
pNot forall a b. (a -> b) -> a -> b
$ forall p. PLike p => PParameter p -> Greskell p
pEq forall a b. (a -> b) -> a -> b
$ Greskell Int
10 :: Greskell (P Int)), Text
"P.not(P.eq(10))")
, (forall a. ToGreskell a => a -> Text
toGremlin (forall p. PLike p => PParameter p -> Greskell p
pEq forall a b. (a -> b) -> a -> b
$ Text -> Greskell Text
string Text
"hoge" :: Greskell (P Text)), Text
"P.eq(\"hoge\")")
, (forall a. ToGreskell a => a -> Text
toGremlin (forall p. PLike p => PParameter p -> PParameter p -> Greskell p
pInside Greskell Int
10 Greskell Int
20 :: Greskell (P Int)), Text
"P.inside(10,20)")
, (forall a. ToGreskell a => a -> Text
toGremlin (forall p. PLike p => [PParameter p] -> Greskell p
pWithin [Greskell Text
"foo", Greskell Text
"bar", Greskell Text
"hoge"] :: Greskell (P Text)), Text
"P.within(\"foo\",\"bar\",\"hoge\")")
, (forall a. ToGreskell a => a -> Text
toGremlin forall a. Greskell (Order a)
oDesc, Text
"Order.desc")
, (forall a. ToGreskell a => a -> Text
toGremlin forall a. Greskell (Order a)
oAsc, Text
"Order.asc")
, (forall a. ToGreskell a => a -> Text
toGremlin forall a. Greskell (Order a)
oDecr, Text
"Order.decr")
, (forall a. ToGreskell a => a -> Text
toGremlin forall a. Greskell (Order a)
oIncr, Text
"Order.incr")
]