Arrow composition must be associative:

(a ∘ b) ∘ c == a ∘ (b ∘ c)

Support matching directed edges without assigning aliases: ->, <-.

Boilerplate reduction.

TBD: I'm not really confident with Category Theory, so I'll fill the description after a couple of discussions.

• Arrows
  • Definition
  • Composition
    • syntax compose
    • syntax andThen
  • Unchaining - recursive decomposition
  • Pipes - arrows of tuples
    • Splitting - A ~> (B, C, D, E)
    • processing a single tuple element (A, B, C, D) ~> (A, E, C, D), similar to first/second
    • Joining - (A, B, C) ~> D
• Functor - map arrows
  • generic functor for composition arrow
  • generic functor for split arrow

Use pattern match if guard for constructing WHERE cypher clause.

Selector is an optic that preserves selection path at type-level.

Typeclasses:

• AllAliases
• HasAlias
• RenameAlias (todo)
• ...

Introduce syntax for paginating query results.

Introduce syntax for boolean expressions:

• OR
• AND
• XOR
• NOT

Given two queries

q1 = MATCH $pattern1 RETURN $result1
q2 = MATCH $pattern2 RETURN $result2

The merged query should be

q1 ∪ q2 = MATCH $pattern1, $pattern2 RETURN $result1, $result2 

Support returning errors in transaction monad.

Introduce graph traversal syntax for building dynamic queries.

Define Functors for mapping ScalaExpr arrows to GraphPath.

• Id ⇒ Initial
• SelectField depends on graph representation of selected field
  • Node ⇒ RelationTarget ∘ OutgoingRelation
  • Relation ⇒ OutgoingRelation
  • Property ⇒ PropSelection
• FMap ⇒ ?
• MBind ⇒ ?
• SelectIn ⇒ ?

• Arrow.Split ⇒ ?
• Arrow.Composition ⇒ ?

Vertex and Edge extractors now require outer parentheses in the pattern. It should not.

Vars are used in generated code for

• setting pattern's GraphElem aliases
• defining query's where clause

Remove them if possible.

See also #27.

Introduce shorter syntax for common functions (over nodes/relations).

• labels
• type
• id
• count
• keys

Functors should map high-level expressions to an intermediate level, not to cypher fragments directly.

This layer should describe the paths (arrows) within an abstract graph.
Those paths should then be mapped to cypher expressions.

This layer will also serve as a base for introducing gremlin-like syntax in the future.

• Initial vertex selection
• 'Move to' relation from node
  • Outgoing
  • Incoming
• 'Move to' node from relation
  • Source
  • Target
• Select property

A polymorphic mapper is required for transforming Cypher trees at compile-time.

CypherFragments should include full type information about their sub-fragments.

This information is to be used for static query analysis and manipulation.

Static alias renamer (with fresh names generation) is required for merging queries.

Introduce syntax for equality/inequality expressions:

• =
• <>
• <
• >
• <=
• >=
• IS NULL
• IS NOT NULL

When mapping a composed arrow with a Functor, the associativity property does not comply.

Functor.map(sel3 ∘ (sel2 ∘ sel1)).to[DBArrow] // Compiles
Functor.map((sel3 ∘ sel2) ∘ sel1).to[DBArrow] // Does not compile

The problem appears because the mapping is defined for a composition sel2 ∘ sel1, not for the underlying arrows.

A schema should define model's representation as a sub-graph. Static = compile time.

Introduce syntax for built-in functions calls.

Support matching a single vertex.

A problem with #30.

While transformations by different functions can be chained

object F1 extends Poly1{
    implicit def impl[A]: Case.Aux[Lit[A], Lit[A with X]] = at[Lit[A]](_.asInstanceOf[Lit[A with X]])
  }
object F2 extends Poly1{
    implicit def call[A, Func0 <: String, Params0 <: HList](
      implicit copy: Copy[Call.Aux[A, Func0, Params0], Witness.`'params`.Field[Lit[Float] :: Lit[Boolean] :: HNil] :: HNil]
    ): Case.Aux[Call.Aux[A, Func0, Params0], copy.Out] =
      at[Call.Aux[A, Func0, Params0]](copy(_, 'params ->> (Lit(1.2f) :: Lit(true) :: HNil) :: HNil))
  }

Transform(Transform(call, F2), F1)

A single polymorphic function, defining all the transformations, doesn't work because of diverging implicit expansion

object F3 extends Poly1 {
    implicit def call[A, Func0 <: String, Params0 <: HList](
      implicit copy: Copy[Call.Aux[A, Func0, Params0], Witness.`'params`.Field[Lit[Float] :: Lit[Boolean] :: HNil] :: HNil]
    ): Case.Aux[Call.Aux[A, Func0, Params0], copy.Out] =
      at[Call.Aux[A, Func0, Params0]](copy(_, 'params ->> (Lit(1.2f) :: Lit(true) :: HNil) :: HNil))
    implicit def lit[A]: Case.Aux[Lit[A], Lit[A with X]] = at[Lit[A]](_.asInstanceOf[Lit[A with X]])
  }

Transform(call, F3)
// diverging implicit expansion for type Transform[Call.Aux[String,String("foo"),shapeless.::[Lit[String],shapeless.::[Lit[String],shapeless.HNil]]],TestTransform.F3_2.type]
// starting with method noStringChildren in object TestTransform

Support matching edges of any direction: --, -.

TODO: - syntax fragment breaks IDE compatibility.

Transformer typeclass, introduced as solution for issue #30 cannot apply/chain multiple transformations
due to diverging implicit expansion errors.

Given two queries

q1 = MATCH $pattern1 RETURN $result1
q2 = MATCH $pattern2 RETURN $result2

The merged query should be

q1 ∪ q2 = MATCH $pattern1, $pattern2 RETURN $result1, $result2 

• Create
• Delete (detach)
• Set / Remove
• Foreach

• Introduce an arrow for Scala's Function1 - Func1Arrow
  • override composition (add higher-priority Compose typeclass instance)
• Map ScalaExpr arrows to Func1Arrow
  • Id
  • SelectField
  • FMap
  • MBind
  • Split
  • SelectIn

Support matching relation length.

len ::= ∗ | ∗d | ∗d1.. | ∗..d2 | ∗d1..d2       where d,d1,d2 ∈ N

A schema should define model's representation as a sub-graph. Dynamic = runtime.

• transform only outer CaseDef; right now the underlying CaseDefs are also modified
• most of the Expr are no longer needed

The template is a string containing placeholders that are substituted with parameter values at runtime. While it is possible to run non-parameterized Cypher, good programming practice is to use parameters in Cypher statements. This allows for caching of statements within the Cypher engine, which is beneficial for performance.
(Neo4J developer manual)

Type functor should map arrows at type-level.

Dependent issues: #39, #43, #45.

Use arrows from #38.

• High-level expressions: ScalaExpr
  • Id - identity arrow (self selection)
  • SelectField - expression representing selection of a field of an ADT (case class)
  • FMap - expression representing functor map operation
  • MBind - expression representing monadic bind / flatMap operation
  • SelectIn
    • select sequence index
    • select map key
    • (?) select Option / Either projection value
  • (?) expression for Either projections
  • (?) coproducts
  • execute expression

While Split is a bundle of arrows with common source that represents a kind of product, similar coproduct representation Choose is needed.

In Scala 2.10, scala.reflect.ClassManifest are deprecated, and it is planned to deprecate scala.reflect.Manifest in favor of TypeTags and ClassTags in an upcoming point release. Thus, it is advisable to migrate any Manifest-based APIs to use Tags.

scala-lang

Introduce syntax for ordering query results.

Introduce syntax for cypher lists:

• list constructor [ ..., ... ]
• in expression
• index selection
• index range selection
• + concatenation

TODO