Merge pull request #88 from jml/readme

Draft readme.

Author: teh

README.md

@@ -3,25 +3,89 @@
 [![CircleCI](https://circleci.com/gh/jml/graphql-api.svg?style=shield)](https://circleci.com/gh/jml/graphql-api)
 [![Documentation Status](https://readthedocs.org/projects/haskell-graphql-api/badge/?version=latest)](http://haskell-graphql-api.readthedocs.io/en/latest/?badge=latest)
 
-Sketch of GraphQL stuff
+`graphql-api` helps you implement a robust [GraphQL](http://graphql.org/) API in Haskell. By the time a query makes it to your handler you are dealing with strong, static types that make sense for your problem domain. All your handlers are normal Haskell functions because we derive their type signature from the schema. If you have used [servant](http://haskell-servant.readthedocs.io/en/stable/), this will sound familiar.
 
-## What it is
+The library provides type combinators to create a GraphQL schema, and functions to parse and evaluate queries against the schema.
 
-Aim is to be [servant](http://haskell-servant.readthedocs.io/) for GraphQL.
+You can find the latest release on [hackage](https://hackage.haskell.org/package/graphql-api).
 
-To do this, we're going to need:
+We implement the [GraphQL specification](https://facebook.github.io/graphql/) as best as we can in Haskell. We figure they know what they're doing. Even if an alternative API or behaviour looks nicer, we will defer to the spec.
 
-* Type-level definition of queries and schemas
-* Evaluation of GraphQL queries (and mutations) according to those types.
+## Example
 
-We can build off the
-existing [graphql](http://hackage.haskell.org/package/graphql) library for
-parsing & representing queries.
+Say we have a simple GraphQL schema like:
 
-## Why you might want it
+```graphql
+type Hello {
+  greeting(who: String!): String!
+}
+```
 
-Right now, you don't. We're working on it. Please feel free to contribute by
-filing issues & submitting PRs.
+which defines a single top-level type `Hello` which contains a single field, `greeting`, that takes a single, required argument `who`.
+
+We can define this schema in Haskell and implement a simple handler like so:
+
+```haskell
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeOperators #-}
+
+import Data.Text (Text)
+import Data.Monoid ((<>))
+
+import GraphQL
+import GraphQL.API
+import GraphQL.Resolver (Handler)
+
+type Hello = Object "Hello" '[]
+  '[ Argument "who" Text :> Field "greeting" Text ]
+
+hello :: Handler IO Hello
+hello = pure (\who -> pure ("Hello " <> who))
+
+run :: Text -> IO Response
+run = interpretAnonymousQuery @Hello hello
+```
+
+We require GHC 8.0.2 or later for features like the `@Hello` type application, and for certain bug fixes.
+
+With the code above we can now run a query:
+
+```haskell
+run "{ greeting(who: \"mort\") }"
+```
+
+Which will produce the following GraphQL response:
+
+```json
+{
+  data: {
+    greeting: "Hello mort"
+  }
+}
+```
+
+## Status
+
+Our current goal is to gather feedback. We have learned a lot about GraphQL in the course of making this library, but we don't know what a good GraphQL library looks like in Haskell. Please [let us know](https://github.com/jml/graphql-api/issues/new) what you think. We won't mind if you file a bug telling us how good the library is.
+
+Because we're still learning, we make **no** guarantees about API stability, or anything at all really.
+
+We are tracking open problems, missing features & wishlist items in [GitHub's issue tracker](https://github.com/jml/graphql-api/issues).
+
+## Roadmap
+
+* Near future:
+  - Better error messages (this is really important to us)
+  - Full support for recursive data types
+  - Close off lose ends in current implementation & gather feedback
+* Medium future:
+  - Full schema validation
+  - Schema introspection
+  - Stabilize public API
+* Long term:
+  - Derive client implementations from types
+  - Allow users to implement their own type combinators
 
 ## References