2

I'm using a functional library (Gremlin) to query a graph database. Invoking it looks like this:

g.V().has(...).out(...).hasLabel(...).in(...).next();

Some of my functional chains are very long, and I'd like to be able to reuse pieces of them for DRY purposes. For example:

const postProjection = () => (
  project("id", "title")
  .by(__.id())
  .by("title")
)

g.V().hasLabel("post").postProjection().next()

I know this doesn't work but that is the concept. I want to encapsulate a piece of this chain into a function that I can (somehow) inject into various other function chains from this library where needed. By dynamically constructing these calls with reusable segments I could dramatically cut down on repetition.

Is this possible to do?

Tom O.
  • 5,730
  • 2
  • 21
  • 35
Fook
  • 5,320
  • 7
  • 35
  • 57

2 Answers2

3

If you want to call it using your exact syntax, you'd have to add functions to the Vertex (or whatever) prototype using something like this answer. That's sort of verbose, though, and not really the expected way to solve something like that. I would recommend making it a regular function call, for which your existing solution is pretty close except for needing a parameter:

const postProjection = (vs) => (
  vs
  .project("id", "title")
  .by(__.id())
  .by("title")
)

const vs = g.V().hasLabel("post")
postProjection(vs).next()
Karl Bielefeldt
  • 47,314
  • 10
  • 60
  • 94
1

Maybe you can use a type that implements functor and lets you invoke methods of the inner object:

const foo = i => (console.log(i), {foo, i});

const Box = o => ({
  map: f => Box(f(o)),
  run: (k, ...args) => Box(o[k] (...args)),
  get: o
});

const fun1 = o =>
  o.foo(3).foo(4)

const fun2 = o =>
  o.foo(7).foo(8);

console.log(
  Box(foo(1).foo(2))
    .map(fun1) // lift normal function into the type
    .run("foo", 5)
    .run("foo", 6)
    .map(fun2)
    .run("foo", 9)
    .get // escape from the type
    .foo(10));