diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file 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. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +import Distribution.Simple + +main = defaultMain diff --git a/features/Main.hs b/features/Main.hs new file mode 100644 --- /dev/null +++ b/features/Main.hs @@ -0,0 +1,18 @@ +module Main where + +import Env +import qualified Spec +import System.Exit (exitFailure, exitSuccess) +import Test.Hspec.Runner (Summary (Summary), hspecResult) + +main :: IO () +main = do + started <- envStart + if started + then do + Summary _ numFailures <- hspecResult Spec.spec + envStop + if numFailures /= 0 + then exitFailure + else exitSuccess + else exitFailure diff --git a/grakn.cabal b/grakn.cabal new file mode 100644 --- /dev/null +++ b/grakn.cabal @@ -0,0 +1,102 @@ +name: grakn +version: 0.2.0 +synopsis: A Haskell client for +description: A Haskell client for +license: Apache-2.0 +license-file: LICENSE +homepage: https://github.com/graknlabs/grakn-haskell +author: Grakn Labs +maintainer: community@grakn.ai +category: Database,Graphs +build-type: Simple +extra-source-files: test/Example.lhs +cabal-version: >=1.10 + +source-repository head + type: git + location: http://github.com/graknlabs/grakn-haskell + +library + build-depends: base >= 4.7 && < 5 + , containers == 0.5.* + , process == 1.4.* + , aeson == 1.* + , scientific == 0.3.* + , text == 1.2.* + , regex-posix == 0.95.* + , servant == 0.9.* + , servant-client + , http-client + , mtl + , http-media + hs-source-dirs: src + exposed-modules: Grakn + other-modules: Grakn.Util + , Grakn.Query + , Grakn.Pattern + , Grakn.Property + , Grakn.Client + default-language: Haskell2010 + + default-extensions: MultiParamTypeClasses + , FlexibleInstances + , FlexibleContexts + , DataKinds + , TypeOperators + +test-suite test + type: exitcode-stdio-1.0 + main-is: Main.hs + hs-source-dirs: test,src + build-depends: base >= 4.7 && < 5 + , grakn + , containers == 0.5.* + , process == 1.4.* + , aeson == 1.0.* + , scientific == 0.3.* + , text == 1.2.* + , regex-posix == 0.95.* + , servant == 0.9.* + , servant-client + , http-client + , mtl + , http-media + , hspec + , QuickCheck >= 2.8 + , markdown-unlit + , MissingH + other-modules: Example + default-language: Haskell2010 + ghc-options: -pgmL markdown-unlit + default-extensions: MultiParamTypeClasses + , FlexibleInstances + , FlexibleContexts + , DataKinds + , TypeOperators + +test-suite accept + type: exitcode-stdio-1.0 + main-is: Main.hs + hs-source-dirs: features,src + build-depends: base >= 4.7 && < 5 + , grakn + , containers == 0.5.* + , process == 1.4.* + , aeson == 1.0.* + , scientific == 0.3.* + , text == 1.2.* + , regex-posix == 0.95.* + , servant == 0.9.* + , servant-client + , http-client + , mtl + , http-media + , hspec + , markdown-unlit + , MissingH + default-language: Haskell2010 + default-extensions: MultiParamTypeClasses + , FlexibleInstances + , FlexibleContexts + , DataKinds + , TypeOperators diff --git a/src/Grakn.hs b/src/Grakn.hs new file mode 100644 --- /dev/null +++ b/src/Grakn.hs @@ -0,0 +1,48 @@ +module Grakn + ( MatchQuery + , Graph(Graph, keyspace, url) + , GraknError + , Result(MatchResult, InsertResult, AskResult, CountResult, + DeleteResult) + , Var + , Name + , Value(..) + , defaultUrl + , defaultKeyspace + , execute + , match + , select + , distinct + , limit + , var + , name + , isa + , (-:) + , (.:) + , rp + , (<:) + , rel + , has + , hasText + , var_ + ) where + +import Data.Text (Text) +import Grakn.Client (GraknError, Graph (Graph, keyspace, url), Result (AskResult, CountResult, DeleteResult, InsertResult, MatchResult), + defaultKeyspace, defaultUrl, execute) +import Grakn.Pattern +import Grakn.Property +import Grakn.Query +import Grakn.Util (Convert) + +-- |Specify a property has a particular type +(-:) :: (Convert p Pattern, Convert a VarOrName) => p -> a -> Pattern +(-:) = isa + +-- |Shorthand to define a relation +rel :: Convert a RolePlayer => [a] -> Pattern +rel = (var_ <:) + +-- |Specify a property has a resource +hasText :: (Convert p Pattern) => p -> Name -> Text -> Pattern +hasText = has diff --git a/src/Grakn/Client.hs b/src/Grakn/Client.hs new file mode 100644 --- /dev/null +++ b/src/Grakn/Client.hs @@ -0,0 +1,115 @@ +{-# LANGUAGE OverloadedStrings #-} + +module Grakn.Client + ( Graph(Graph, keyspace, url) + , Concept(Concept, cid, cname, ctype, value) + , GraknError + , Result(MatchResult, InsertResult, AskResult, CountResult, + DeleteResult) + , defaultUrl + , defaultKeyspace + , execute + ) where + +import Control.Applicative (empty) +import Data.Aeson (FromJSON, ToJSON, encode, parseJSON, + (.:), (.:?)) +import qualified Data.Aeson as Aeson +import Data.Foldable (asum) +import Data.Map (Map) +import Data.Proxy (Proxy (Proxy)) +import Data.Text (Text) +import Grakn.Property (Name, Value, Var) +import Grakn.Query (IsQuery (queryString)) +import Network.HTTP.Client (defaultManagerSettings, newManager) +import Network.HTTP.Media ((//)) +import Servant.API +import Servant.API.ContentTypes (eitherDecodeLenient) +import Servant.Client + +data Graph = Graph + { url :: BaseUrl + , keyspace :: String + } + +newtype GraknError = + GraknError String + deriving (Eq, Show) + +-- |A result of a match query, binding variables to concepts +data Result + = MatchResult [Map Var Concept] + | InsertResult [Text] + | AskResult Bool + | CountResult Integer + | DeleteResult + deriving (Show, Eq) + +-- |A concept in the graph +data Concept = Concept + { cid :: Text + , cname :: Maybe Name + , ctype :: Maybe Name + , value :: Maybe Value + } deriving (Show, Eq) + +-- |The default Grakn URL, accessing localhost +defaultUrl :: BaseUrl +defaultUrl = BaseUrl Http "localhost" 4567 "" + +-- |The default Grakn keyspace +defaultKeyspace :: String +defaultKeyspace = "grakn" + +execute :: IsQuery q => Graph -> q -> IO (Either ServantError Result) +execute (Graph u ks) query = do + manager <- newManager defaultManagerSettings + let env = ClientEnv manager u + runClientM (graqlGet (queryString query) ks) env + +type Keyspace = QueryParam "keyspace" String + +type Infer = QueryParam "infer" Bool + +type Materialise = QueryParam "materialise" Bool + +type Body = ReqBody '[ PlainText] String + +type GraknParams + = Keyspace :> Infer :> Materialise :> Body :> Post '[ GraqlJSON] Result + +-- |A type describing the REST API we use to execute queries +type GraknAPI = "graph" :> "graql" :> "execute" :> GraknParams + +graknAPI :: Proxy GraknAPI +graknAPI = Proxy + +graqlGet :: String -> String -> ClientM Result +graqlGet query ks = client graknAPI (Just ks) (Just False) (Just False) query + +instance FromJSON Concept where + parseJSON (Aeson.Object obj) = + Concept <$> (obj .: "id") <*> (obj .:? "name") <*> (obj .:? "isa") <*> + (obj .:? "value") + parseJSON _ = empty + +instance FromJSON Result where + parseJSON val = + asum + [ MatchResult <$> parseJSON val + , InsertResult <$> parseJSON val + , AskResult <$> parseJSON val + , CountResult <$> parseJSON val + , pure DeleteResult + ] + +data GraqlJSON + +instance Accept GraqlJSON where + contentType _ = "application" // "graql+json" + +instance ToJSON a => MimeRender GraqlJSON a where + mimeRender _ = encode + +instance FromJSON a => MimeUnrender GraqlJSON a where + mimeUnrender _ = eitherDecodeLenient diff --git a/src/Grakn/Pattern.hs b/src/Grakn/Pattern.hs new file mode 100644 --- /dev/null +++ b/src/Grakn/Pattern.hs @@ -0,0 +1,58 @@ +module Grakn.Pattern + ( Pattern + , var_ + , isa + , (<:) + , has + ) where + +import Grakn.Property +import Grakn.Util (Convert (convert), spaces, with) + +-- |A pattern to find in the graph +data Pattern = + Pattern (Maybe VarOrName) + [Property] + +-- |Create an anonymous variable +var_ :: Pattern +var_ = Pattern Nothing [] + +-- |Specify a property has a particular type +isa :: (Convert p Pattern, Convert a VarOrName) => p -> a -> Pattern +patt `isa` x = addProperty patt (Isa $ convert x) + +-- |Specify a property is a relation between other variables +(<:) :: (Convert p Pattern, Convert a RolePlayer) => p -> [a] -> Pattern +patt <: cs = addProperty patt (Rel $ map convert cs) + +-- |Specify a property has a resource +has :: + (Convert p Pattern, Convert a (Either Value Var)) + => p + -> Name + -> a + -> Pattern +has patt rt v = addProperty patt (Has rt $ convert v) + +showProps :: Show a => [a] -> String +showProps = spaces . reverse + +addPropToPattern :: Pattern -> Property -> Pattern +addPropToPattern (Pattern n props) prop = Pattern n (prop : props) + +addProperty :: Convert a Pattern => a -> Property -> Pattern +addProperty = addPropToPattern . convert + +instance Show Pattern where + show (Pattern v []) = v `with` "" ++ ";" + show (Pattern v props) = v `with` " " ++ showProps props ++ ";" + +instance Convert Var Pattern where + convert = convert . (convert :: Var -> VarOrName) + +instance Convert Name Pattern where + convert = convert . (convert :: Name -> VarOrName) + +instance Convert VarOrName Pattern where + convert v = Pattern (Just v) [] diff --git a/src/Grakn/Property.hs b/src/Grakn/Property.hs new file mode 100644 --- /dev/null +++ b/src/Grakn/Property.hs @@ -0,0 +1,145 @@ +module Grakn.Property + ( Property(..) + , RolePlayer + , Var + , Name + , VarOrName + , Value(..) + , var + , name + , (.:) + , rp + ) where + +import Control.Applicative (empty) +import Data.Aeson (FromJSON, FromJSONKey, + FromJSONKeyFunction (FromJSONKeyText), + parseJSON) +import qualified Data.Aeson as Aeson +import Data.Scientific (Scientific) +import Data.Text (Text, unpack) +import Grakn.Util (Convert (convert), commas, with) +import Text.Regex.Posix ((=~)) + +-- |A property of a concept +data Property + = Isa VarOrName + | NameProperty Name + | Rel [RolePlayer] + | Has Name + (Either Value Var) + +-- |A variable name wildcard that will represent a concept in the results +newtype Var = + Var Text + deriving (Eq, Ord) + +-- |A name of something in the graph +newtype Name = + Name Text + deriving (Eq) + +-- |Something that may be a variable name or a type name +data VarOrName + = VarName Var + | TypeName Name + +-- |A value of a resource +data Value + = ValueString Text + | ValueNumber Scientific + | ValueBool Bool + deriving (Eq) + +-- |A casting, relating a role type and role player +data RolePlayer = + RolePlayer (Maybe VarOrName) + Var + +-- |Create a variable +var :: Text -> Var +var = Var + +-- |Create a name of something in the graph +name :: Text -> Name +name = Name + +-- |A casting in a relation between a role type and a role player +(.:) :: Convert a VarOrName => a -> Var -> RolePlayer +rt .: player = RolePlayer (Just $ convert rt) player + +-- |A casting in a relation without a role type +rp :: Var -> RolePlayer +rp = RolePlayer Nothing + +nameRegex :: String +nameRegex = "^[a-zA-Z_][a-zA-Z0-9_-]*$" + +instance Show Property where + show (Isa varOrName) = "isa " ++ show varOrName + show (NameProperty n) = "type-name " ++ show n + show (Rel castings) = "(" ++ commas castings ++ ")" + show (Has rt value) = "has " ++ show rt ++ " " ++ showEither value + +instance Show RolePlayer where + show (RolePlayer roletype player) = roletype `with` ": " ++ show player + +instance Show Value where + show (ValueString text) = show text + show (ValueNumber num) = show num + show (ValueBool bool) = show bool + +instance Show Name where + show (Name text) + | str =~ nameRegex = str + | otherwise = show text + where + str = unpack text + +instance Show Var where + show (Var v) = '$' : unpack v + +instance Show VarOrName where + show (VarName v) = show v + show (TypeName t) = show t + +instance Convert Var VarOrName where + convert = VarName + +instance Convert Name VarOrName where + convert = TypeName + +instance Convert Var RolePlayer where + convert = rp + +instance Convert Var (Either Value Var) where + convert = Right + +instance Convert Text (Either Value Var) where + convert = Left . ValueString + +instance Convert Scientific (Either Value Var) where + convert = Left . ValueNumber + +instance Convert Bool (Either Value Var) where + convert = Left . ValueBool + +instance FromJSON Value where + parseJSON (Aeson.String s) = return $ ValueString s + parseJSON (Aeson.Number n) = return $ ValueNumber n + parseJSON (Aeson.Bool b) = return $ ValueBool b + parseJSON _ = empty + +instance FromJSON Name where + parseJSON (Aeson.String s) = return $ name s + parseJSON _ = empty + +instance FromJSON Var where + parseJSON (Aeson.String s) = return $ var s + parseJSON _ = empty + +instance FromJSONKey Var where + fromJSONKey = FromJSONKeyText var + +showEither :: (Show a, Show b) => Either a b -> String +showEither = either show show diff --git a/src/Grakn/Query.hs b/src/Grakn/Query.hs new file mode 100644 --- /dev/null +++ b/src/Grakn/Query.hs @@ -0,0 +1,52 @@ +module Grakn.Query + ( IsQuery(queryString) + , MatchQuery + , match + , select + , limit + , distinct + ) where + +import Grakn.Pattern +import Grakn.Property +import Grakn.Util + +class IsQuery q where + queryString :: q -> String + +-- |A Graql 'match' query that finds a pattern in the graph +data MatchQuery + = Match [Pattern] + | Select MatchQuery + [Var] + | Limit MatchQuery + Integer + | Distinct MatchQuery + +-- |Create a match query by providing a list of patterns +match :: Convert a Pattern => [a] -> MatchQuery +match = Match . map convert + +-- |Select variables from a match query, intended to be used infix +select :: [Var] -> MatchQuery -> MatchQuery +select = flip Select + +-- |Limit a match query, intended to be used infix +limit :: Integer -> MatchQuery -> MatchQuery +limit = flip Limit + +-- |Retrieve only distinct results from a match query +distinct :: MatchQuery -> MatchQuery +distinct = Distinct + +instance Show MatchQuery where + show (Match patts) = "match " ++ spaces patts + show (Select mq vars) = show mq ++ " select " ++ commas vars ++ ";" + show (Limit mq lim) = show mq ++ " limit " ++ show lim ++ ";" + show (Distinct mq) = show mq ++ " distinct;" + +instance IsQuery MatchQuery where + queryString = show + +instance IsQuery String where + queryString = id diff --git a/src/Grakn/Util.hs b/src/Grakn/Util.hs new file mode 100644 --- /dev/null +++ b/src/Grakn/Util.hs @@ -0,0 +1,27 @@ +module Grakn.Util + ( Convert(convert) + , with + , commas + , spaces + ) where + +import Data.List (intercalate) + +class Convert a b where + convert :: a -> b + +instance Convert a a where + convert = id + +with :: Show a => Maybe a -> String -> String +(Just val) `with` suffix = show val ++ suffix +Nothing `with` _ = "" + +commas :: Show a => [a] -> String +commas = interList ", " + +spaces :: Show a => [a] -> String +spaces = interList " " + +interList :: Show a => String -> [a] -> String +interList sep = intercalate sep . map show diff --git a/test/Example.lhs b/test/Example.lhs new file mode 100644 --- /dev/null +++ b/test/Example.lhs @@ -0,0 +1,93 @@ +# Grakn Haskell Client + +A Haskell client for [Grakn](http://grakn.ai). + +Requires Grakn 0.16. + +# Installation + +To install the Grakn client, simply add this to your cabal file: + +``` +build-depends: grakn +``` + +You will also need access to a Grakn database. +Head [here](https://grakn.ai/pages/documentation/get-started/setup-guide.html) +to get started with Grakn. + +# Quickstart + +Begin by importing the client: + +```haskell +{-# LANGUAGE OverloadedStrings #-} + +module Example where + +import Grakn + +import Data.Function ((&)) +``` + +Define the type names: + +```haskell +person :: Name +person = name "person" + +husband :: Name +husband = name "husband" + +wife :: Name +wife = name "wife" + +marriage :: Name +marriage = name "marriage" +``` + +Define the variables: + +```haskell +x :: Var +x = var "x" + +y :: Var +y = var "y" +``` + +We can translate the following query into Haskell: + +```graql +match $x isa person, (husband: $x, wife: $y) isa marriage; select $y; +``` + +```haskell +query :: MatchQuery +query = match + [ x `isa` person + , rel [husband .: x, wife .: y] `isa` marriage + ] & select [y] +``` + +We can also use infix functions like `(-:)` instead of `isa`: + +```haskell +otherQuery :: MatchQuery +otherQuery = match + [ x -: person + , rel [husband .: x, wife .: y] -: marriage + ] & select [y] +``` + +To execute and print the results of our query: + +```haskell +graph :: Graph +graph = Graph defaultUrl "my-keyspace" + +main :: IO () +main = do + result <- execute graph query + print result +``` diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover #-}