Data.Greskell.Greskell

Type

data Greskell a

Gremlin expression of type a.

Greskell is essentially just a piece of Gremlin script with a phantom type. The type a represents the type of data that the script is supposed to evaluate to.

Eq and Ord instances compare Gremlin scripts, NOT the values they evaluate to.

Instances

Functor Greskell

Unsafely convert the phantom type.

Defined in Data.Greskell.Greskell

Methods

fmap :: (a -> b) -> Greskell a -> Greskell b

(<$) :: a -> Greskell b -> Greskell a

Eq (Greskell a)

Defined in Data.Greskell.Greskell

Methods

(==) :: Greskell a -> Greskell a -> Bool

(/=) :: Greskell a -> Greskell a -> Bool

Fractional a => Fractional (Greskell a)

Floating-point number literals and numeric operation in Gremlin

Defined in Data.Greskell.Greskell

Methods

(/) :: Greskell a -> Greskell a -> Greskell a

recip :: Greskell a -> Greskell a

fromRational :: Rational -> Greskell a

Num a => Num (Greskell a)

Integer literals and numeric operation in Gremlin

Defined in Data.Greskell.Greskell

Methods

(+) :: Greskell a -> Greskell a -> Greskell a

(-) :: Greskell a -> Greskell a -> Greskell a

(*) :: Greskell a -> Greskell a -> Greskell a

negate :: Greskell a -> Greskell a

abs :: Greskell a -> Greskell a

signum :: Greskell a -> Greskell a

fromInteger :: Integer -> Greskell a

Ord (Greskell a)

Defined in Data.Greskell.Greskell

Methods

compare :: Greskell a -> Greskell a -> Ordering

(<) :: Greskell a -> Greskell a -> Bool

(<=) :: Greskell a -> Greskell a -> Bool

(>) :: Greskell a -> Greskell a -> Bool

(>=) :: Greskell a -> Greskell a -> Bool

max :: Greskell a -> Greskell a -> Greskell a

min :: Greskell a -> Greskell a -> Greskell a

Show (Greskell a)

Defined in Data.Greskell.Greskell

Methods

showsPrec :: Int -> Greskell a -> ShowS

show :: Greskell a -> String

showList :: [Greskell a] -> ShowS

IsString a => IsString (Greskell a)

Same as string except for the input and output type.

Defined in Data.Greskell.Greskell

Methods

fromString :: String -> Greskell a

IsString a => Semigroup (Greskell a)

Semigroup operator <> on Greskell assumes String concatenation on Gremlin.

Defined in Data.Greskell.Greskell

Methods

(<>) :: Greskell a -> Greskell a -> Greskell a

sconcat :: NonEmpty (Greskell a) -> Greskell a

stimes :: Integral b => b -> Greskell a -> Greskell a

IsString a => Monoid (Greskell a)

Monoidal operations on Greskell assumes String operations in Gremlin. mempty is the empty String, and mappend is String concatenation.

Defined in Data.Greskell.Greskell

Methods

mempty :: Greskell a

mappend :: Greskell a -> Greskell a -> Greskell a

mconcat :: [Greskell a] -> Greskell a

ToGreskell (Greskell a)

It's just id.

Defined in Data.Greskell.Greskell

Associated Types

type GreskellReturn (Greskell a)

Methods

toGreskell :: Greskell a -> Greskell (GreskellReturn (Greskell a))

type GreskellReturn (Greskell a)

Defined in Data.Greskell.Greskell

type GreskellReturn (Greskell a) = a

class ToGreskell a where

Something that can convert to Greskell.

Associated Types

type GreskellReturn a

type of return value by Greskell.

Methods

toGreskell :: a -> Greskell (GreskellReturn a)

Instances

ToGreskell (Greskell a)

It's just id.

Defined in Data.Greskell.Greskell

Associated Types

type GreskellReturn (Greskell a)

Methods

toGreskell :: Greskell a -> Greskell (GreskellReturn (Greskell a))

Conversions

toGremlin :: ToGreskell a => a -> Text

Create a readable Gremlin script from Greskell.

toGremlinLazy :: ToGreskell a => a -> Text

Same as toGremlin except that this returns lazy Text.

Literals

Functions to create literals in Gremlin script. Use fromInteger, valueInt or gvalueInt to create integer literals. Use fromRational or number to create floating-point data literals.

string :: Text -> Greskell Text

Create a String literal in Gremlin script. The content is automatically escaped.

>>> toGremlin $ string "foo bar"
"\"foo bar\""
>>> toGremlin $ string "escape newline\n escape dollar $"
"\"escape newline\\n escape dollar \\$\""

true :: Greskell Bool

Boolean true literal.

>>> toGremlin true
"true"

false :: Greskell Bool

Boolean false literal.

>>> toGremlin false
"false"

list :: [Greskell a] -> Greskell [a]

List literal.

>>> toGremlin $ list ([100, 200, 300] :: [Greskell Int])
"[100,200,300]"

single :: Greskell a -> Greskell [a]

Make a list with a single object. Useful to prevent the Gremlin Server from automatically iterating the result object.

>>> toGremlin $ single ("hoge" :: Greskell Text)
"[\"hoge\"]"

number :: Scientific -> Greskell Scientific

Arbitrary precision number literal, like "123e8".

>>> toGremlin $ number 123e8
"1.23e10"

value :: Value -> Greskell Value

Aeson Value literal.

>>> toGremlin $ value Aeson.Null
"null"
>>> toGremlin $ value $ Aeson.toJSON $ ([10, 20, 30] :: [Int])
"[10.0,20.0,30.0]"
>>> toGremlin $ value $ Aeson.Object mempty
"[:]"

Note that Number does not distinguish integers from floating-point numbers, so value function may format an integer as a floating-point number. To ensure formatting as integers, use valueInt.

valueInt :: Integral a => a -> Greskell Value

Integer literal as Value type.

>>> toGremlin $ valueInt (100 :: Int)
"100"

Since: 0.1.2.0

gvalue :: Value -> Greskell GValue

Value literal as GValue type.

Since: 0.1.2.0

gvalueInt :: Integral a => a -> Greskell GValue

Integer literal as GValue type.

>>> toGremlin $ gvalueInt (256 :: Int)
"256"

Since: 0.1.2.0

Unsafe constructors

unsafeGreskell

Arguments

:: Text

Gremlin script

-> Greskell a

Unsafely create a Greskell of arbitrary type. The given Gremlin script is printed as-is.

>>> toGremlin $ unsafeGreskell "x + 100"
"x + 100"

unsafeGreskellLazy

Arguments

:: Text

Gremlin script

-> Greskell a

Same as unsafeGreskell, but it takes lazy Text.

unsafeFunCall

Arguments

:: Text

function name

-> [Text]

arguments

-> Greskell a

return value of the function call

Unsafely create a Greskell that calls the given function with the given arguments.

>>> toGremlin $ unsafeFunCall "add" ["10", "20"]
"add(10,20)"

unsafeMethodCall

Arguments

:: Greskell a

target object

-> Text

method name

-> [Text]

arguments

-> Greskell b

return value of the method call

Unsafely create a Greskell that calls the given object method call with the given target and arguments.

>>> toGremlin $ unsafeMethodCall ("foobar" :: Greskell Text) "length" []
"(\"foobar\").length()"