Function mapOperation

Parameters

• op: Algebra.Operation

  The Operation to recurse on.
• callbacks: {
      add?: (op: Algebra.Add, factory: Factory) => utils.RecurseResult;
      alt?: (op: Algebra.Alt, factory: Factory) => utils.RecurseResult;
      ask?: (op: Algebra.Ask, factory: Factory) => utils.RecurseResult;
      bgp?: (op: Algebra.Bgp, factory: Factory) => utils.RecurseResult;
      clear?: (op: Algebra.Clear, factory: Factory) => utils.RecurseResult;
      compositeupdate?: (
          op: Algebra.CompositeUpdate,
          factory: Factory,
      ) => utils.RecurseResult;
      construct?: (
          op: Algebra.Construct,
          factory: Factory,
      ) => utils.RecurseResult;
      copy?: (op: Algebra.Copy, factory: Factory) => utils.RecurseResult;
      create?: (op: Algebra.Create, factory: Factory) => utils.RecurseResult;
      deleteinsert?: (
          op: Algebra.DeleteInsert,
          factory: Factory,
      ) => utils.RecurseResult;
      describe?: (op: Algebra.Describe, factory: Factory) => utils.RecurseResult;
      distinct?: (op: Algebra.Distinct, factory: Factory) => utils.RecurseResult;
      drop?: (op: Algebra.Drop, factory: Factory) => utils.RecurseResult;
      expression?: (
          op: Algebra.TypedOperation<EXPRESSION>,
          factory: Factory,
      ) => utils.RecurseResult;
      extend?: (op: Algebra.Extend, factory: Factory) => utils.RecurseResult;
      filter?: (op: Algebra.Filter, factory: Factory) => utils.RecurseResult;
      from?: (op: Algebra.From, factory: Factory) => utils.RecurseResult;
      graph?: (op: Algebra.Graph, factory: Factory) => utils.RecurseResult;
      group?: (op: Algebra.Group, factory: Factory) => utils.RecurseResult;
      inv?: (op: Algebra.Inv, factory: Factory) => utils.RecurseResult;
      join?: (op: Algebra.Join, factory: Factory) => utils.RecurseResult;
      leftjoin?: (op: Algebra.LeftJoin, factory: Factory) => utils.RecurseResult;
      link?: (op: Algebra.Link, factory: Factory) => utils.RecurseResult;
      load?: (op: Algebra.Load, factory: Factory) => utils.RecurseResult;
      minus?: (op: Algebra.Minus, factory: Factory) => utils.RecurseResult;
      move?: (op: Algebra.Move, factory: Factory) => utils.RecurseResult;
      nop?: (op: Algebra.Nop, factory: Factory) => utils.RecurseResult;
      nps?: (op: Algebra.Nps, factory: Factory) => utils.RecurseResult;
      OneOrMorePath?: (
          op: Algebra.OneOrMorePath,
          factory: Factory,
      ) => utils.RecurseResult;
      orderby?: (op: Algebra.OrderBy, factory: Factory) => utils.RecurseResult;
      path?: (op: Algebra.Path, factory: Factory) => utils.RecurseResult;
      pattern?: (op: Algebra.Pattern, factory: Factory) => utils.RecurseResult;
      project?: (op: Algebra.Project, factory: Factory) => utils.RecurseResult;
      reduced?: (op: Algebra.Reduced, factory: Factory) => utils.RecurseResult;
      seq?: (op: Algebra.Seq, factory: Factory) => utils.RecurseResult;
      service?: (op: Algebra.Service, factory: Factory) => utils.RecurseResult;
      slice?: (op: Algebra.Slice, factory: Factory) => utils.RecurseResult;
      union?: (op: Algebra.Union, factory: Factory) => utils.RecurseResult;
      values?: (op: Algebra.Values, factory: Factory) => utils.RecurseResult;
      ZeroOrMorePath?: (
          op: Algebra.ZeroOrMorePath,
          factory: Factory,
      ) => utils.RecurseResult;
      ZeroOrOnePath?: (
          op: Algebra.ZeroOrOnePath,
          factory: Factory,
      ) => utils.RecurseResult;
  } & {
      aggregate?: (
          expr: Algebra.TypedExpression<AGGREGATE>,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
      existence?: (
          expr: Algebra.ExistenceExpression,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
      named?: (
          expr: Algebra.NamedExpression,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
      operator?: (
          expr: Algebra.OperatorExpression,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
      term?: (
          expr: Algebra.TermExpression,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
      wildcard?: (
          expr: Algebra.WildcardExpression,
          factory: Factory,
      ) => utils.ExpressionRecurseResult;
  }

  A map of required callback Operations.
• Optionalfactory: Factory

  Factory used to create new Operations. Will use default factory if none is provided.