Variable flowrCapabilitiesConst

Type declaration

• Readonlycapabilities: readonly [
      {
          capabilities: readonly [
              {
                  capabilities: readonly [
                      {
                          description: "_Recognize symbol uses like `a`, `plot`, ..._ (i.e., \"normal variables or function calls\").";
                          id: "name-normal";
                          name: "Normal";
                          supported: "fully";
                          url: [
                              {
                                  href: "https://adv-r.hadley.nz/names-values.html#binding-basics";
                                  name: string;
                              },
                              {
                                  href: "https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Identifiers-1";
                                  name: string;
                              },
                          ];
                      },
                      {
                          description: "_Recognize `\"a\"`, `'plot'`, ..._ In general, R allows to envelop names in quotations to allow for special characters such as spaces in variable names. However, this only works in the context of definitions. To access these names as variables, one has to either use function such as `get` or escape the name with backticks.";
                          id: "name-quoted";
                          name: "Quoted";
                          supported: "fully";
                          url: [
                              {
                                  href: "https://adv-r.hadley.nz/names-values.html#non-syntactic";
                                  name: string;
                              },
                          ];
                      },
                      {
                          description: "_Recognize `` `a` ``, `` `plot` ``, ..._";
                          id: "name-escaped";
                          name: "Escaped";
                          supported: "fully";
                          url: [
                              {
                                  href: "https://adv-r.hadley.nz/names-values.html#non-syntactic";
                                  name: string;
                              },
                          ];
                      },
                      {
                          description: "_Recognize functions which resolve strings as identifiers, such as `get`, ..._";
                          id: "name-created";
                          name: "Created";
                          supported: "partially";
                          url: [{ href: string; name: "flowr#633" }];
                      },
                  ];
                  id: "form";
                  name: "Form";
              },
              {
                  capabilities: readonly [
                      {
                          description: "_For example, tracking a big table of current identifier bindings_";
                          id: "global-scope";
                          name: "Global Scope";
                          supported: "fully";
                      },
                      {
                          description: "_For example, support function definition scopes_";
                          id: "lexicographic-scope";
                          name: "Lexicographic Scope";
                          supported: "fully";
                      },
                      {
                          description: "_Handling [function factories](https://adv-r.hadley.nz/function-factories.html) and friends._ Currently, we do not have enough tests to be sure.";
                          id: "closures";
                          name: "Closures";
                          supported: "partially";
                      },
                      {
                          description: "_For example, using `new.env` and friends_";
                          id: "dynamic-environment-resolution";
                          name: "Dynamic Environment Resolution";
                          supported: "not";
                      },
                      {
                          description: "_Handling side-effects by environments which are not copied when modified_";
                          id: "environment-sharing";
                          name: "Environment Sharing";
                          supported: "not";
                      },
                      {
                          description: "_Separating the resolution for functions and symbols._";
                          id: "search-type";
                          name: "Search Type";
                          supported: "fully";
                      },
                      {
                          description: "_Handling [R's search path](https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Search-path) as explained in [Advanced R](https://adv-r.hadley.nz/environments.html#search-path)._ Currently, _flowR_ does not support dynamic modifications with `attach`, `search`, or `fn_env` and tests are definitely missing. Yet, theoretically, the tooling is all there.";
                          id: "search-path";
                          name: "Search Path";
                          supported: "not";
                      },
                      {
                          description: "_Handling R's namespaces as explained in [Advanced R](https://adv-r.hadley.nz/environments.html#namespaces)_";
                          id: "namespaces";
                          name: "Namespaces";
                          supported: "not";
                      },
                      {
                          description: "_Resolving calls with `::` to their origin._ Accessing external files is allowed, although the name of packages etc. is not resolved correctly.";
                          id: "accessing-exported-names";
                          name: "Accessing Exported Names";
                          supported: "partially";
                      },
                      {
                          description: "_Similar to `::` but for internal names._";
                          id: "accessing-internal-names";
                          name: "Accessing Internal Names";
                          supported: "not";
                      },
                      {
                          description: "_Resolve libraries identified with `library`, `require`, `attachNamespace`, ... and attach them to the search path_";
                          id: "library-loading";
                          name: "Library Loading";
                          supported: "not";
                      },
                  ];
                  id: "resolution";
                  name: "Resolution";
              },
          ];
          description: "The recognition of syntactical and non-syntactical names, including their resolutions to corresponding definitions.";
          example: (parser: KnownParser) => Promise<string>;
          id: "names-and-identifiers";
          name: "Names and Identifiers";
      },
      {
          capabilities: readonly [
              {
                  capabilities: readonly [
                      {
                          description: "_Recognize groups done with `(`, `{`, ... (more precisely, their default mapping to the primitive implementations)._";
                          id: "grouping";
                          name: "Grouping";
                          supported: "fully";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Recognize and resolve calls like `f(3)`, `foo::bar(3, c(1,2))`, ..._";
                                  id: "unnamed-arguments";
                                  name: "Unnamed Arguments";
                                  supported: "fully";
                              },
                              {
                                  description: "_Essentially a special form of an unnamed argument as in `foo::bar(3, ,42)`, ..._";
                                  id: "empty-arguments";
                                  name: "Empty Arguments";
                                  supported: "fully";
                              },
                              {
                                  description: "_Recognize and resolve calls like `f(x = 3)`, `foo::bar(x = 3, y = 4)`, ..._";
                                  id: "named-arguments";
                                  name: "Named Arguments";
                                  supported: "fully";
                              },
                              {
                                  description: "_Recognize and resolve calls like `f('x' = 3)`, `foo::bar('x' = 3, \"y\" = 4)`, ..._";
                                  id: "string-arguments";
                                  name: "String Arguments";
                                  supported: "fully";
                              },
                              {
                                  description: "_Correctly bind arguments (including [`pmatch`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/pmatch))._ Currently, we do not have a correct implementation for `pmatch`. Furthermore, more tests would be nice.";
                                  id: "resolve-arguments";
                                  name: "Resolve Arguments";
                                  supported: "partially";
                              },
                              {
                                  description: "_Handle side-effects of arguments (e.g., `f(x <- 3)`, `f(x = y <- 3)`, ...)._ We have not enough tests to be sure";
                                  id: "side-effects-in-argument";
                                  name: "Side-Effects in Argument";
                                  supported: "partially";
                              },
                              {
                                  description: "_Handle side-effects of function calls (e.g., `setXTo(3)`, ...) for example achieved with the super assignment._ We need more tests and handlings. Furthermore, we do not detect side effects with external files, network, logging, etc.";
                                  id: "side-effects-in-function-call";
                                  name: "Side-Effects in Function Call";
                                  supported: "partially";
                              },
                          ];
                          description: "_Recognize and resolve calls like `f(x)`, `foo::bar(x, y)`, ..._";
                          id: "call-normal";
                          name: "Normal Call";
                          supported: "fully";
                      },
                      {
                          description: "_Recognize and resolve calls like `(function(x) x)(3)`, `factory(0)()`, ..._";
                          id: "call-anonymous";
                          name: "Anonymous Calls";
                          supported: "fully";
                      },
                      {
                          description: "_Recognize and resolve calls like `x + y`, `x %>% f(y)`, ..._";
                          id: "infix-calls";
                          name: "Infix Calls";
                          supported: "fully";
                      },
                      {
                          description: "_Handle cases like `print <- function(x) x`, `` `for` <- function(a,b,c) a``, ..._ Currently, we can not handle all of them there are no tests. Still wip as part of desugaring";
                          id: "redefinition-of-built-in-functions-primitives";
                          name: "Redefinition of Built-In Functions/primitives";
                          supported: "partially";
                      },
                      {
                          description: "_Support functions like `setwd` which have an impact on the subsequent program._";
                          id: "functions-with-global-side-effects";
                          name: "Functions with global side effects";
                          supported: "partially";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Detect calls like `x[i]`, `x[i, ,b]`, `x[3][y]`, ... This does not include the real separation of cells, which is handled extra._";
                                  id: "single-bracket-access";
                                  name: "Single Bracket Access";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x[[i]]`, `x[[i, b]]`, ... Similar to single bracket._";
                                  id: "double-bracket-access";
                                  name: "Double Bracket Access";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x$y`, `x$\"y\"`, `x$y$z`, ..._";
                                  id: "dollar-access";
                                  name: "Dollar Access";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x@y`, `x@y@z`, ..._";
                                  id: "slot-access";
                                  name: "Slot Access";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x[i = 3]`, `x[[i=]]`, ..._";
                                  id: "access-with-argument-names";
                                  name: "Access with Argument-Names";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x[]`, `x[2,,42]`, ..._";
                                  id: "access-with-empty";
                                  name: "Access with Empty";
                                  supported: "fully";
                              },
                              {
                                  description: "_Detect calls like `x[i > 3]`, `x[c(1,3)]`, ..._";
                                  id: "subsetting-multiple";
                                  name: "Subsetting (Multiple Indices)";
                                  supported: "fully";
                              },
                          ];
                          id: "index-access";
                          name: "Index Access";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Recognize and resolve calls like `+3`, `-3`, ..._";
                                  id: "unary-operator";
                                  name: "Unary Operator";
                                  supported: "fully";
                              },
                              {
                                  capabilities: readonly [
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { capabilities: ...; id: ...; name: ... },
                                  ];
                                  description: "_Recognize and resolve calls like `3 + 4`, `3 * 4`, ..._";
                                  id: "binary-operator";
                                  name: "Binary Operator";
                                  supported: "fully";
                              },
                          ];
                          id: "operators";
                          name: "Operators";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Handle `if (x) y else z`, `if (x) y`, ..._";
                                  id: "if";
                                  name: "if";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `for (i in 1:3) print(i)`, ..._";
                                  id: "for-loop";
                                  name: "for loop";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `while (x) b`, ..._";
                                  id: "while-loop";
                                  name: "while loop";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `repeat {b; if (x) break}`, ..._";
                                  id: "repeat-loop";
                                  name: "repeat loop";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `break` (including `break()`) ..._";
                                  id: "break";
                                  name: "break";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `next` (including `next()`) ..._";
                                  id: "next";
                                  name: "next";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `switch(3, \"a\", \"b\", \"c\")`, ..._";
                                  id: "switch";
                                  name: "switch";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `return(3)`, ... in function definitions_";
                                  id: "return";
                                  name: "return";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle `try`, `stop`, ..._";
                                  id: "exceptions";
                                  name: "exceptions";
                                  supported: "not";
                              },
                          ];
                          id: "control-flow";
                          name: "Control-Flow";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Handle `function() 3`, ..._";
                                  id: "normal-definition";
                                  name: "Normal";
                                  supported: "fully";
                              },
                              {
                                  capabilities: readonly [
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                  ];
                                  id: "formals";
                                  name: "Formals";
                              },
                              {
                                  description: "_Handle the return of `function() 3`, ..._";
                                  id: "implicit-return";
                                  name: "Implicit Return";
                                  supported: "fully";
                              },
                              {
                                  description: "_Support `\\(x) x`, ..._";
                                  id: "lambda-syntax";
                                  name: "Lambda Syntax";
                                  supported: "fully";
                              },
                          ];
                          id: "function-definitions";
                          name: "Function Definitions";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Handle `&&`, `||`, ..._";
                                  id: "non-strict-logical-operators";
                                  name: "Non-Strict Logical Operators";
                                  supported: "fully";
                              },
                              {
                                  description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.";
                                  id: "built-in-pipe-and-pipe-bind";
                                  name: "Pipe and Pipe-Bind";
                                  supported: "partially";
                              },
                              {
                                  description: "_Handle `:`, `seq`, ... by gathering value information using abstract interpretation._";
                                  id: "built-in-sequencing";
                                  name: "Sequencing";
                                  supported: "not";
                              },
                              {
                                  description: "_Handle `.Internal`, `.Primitive`, ..._ In general we can not handle them as they refer to non-R code. We currently do not support them when used with the function.";
                                  id: "built-in-internal-and-primitive-functions";
                                  name: "Internal and Primitive Functions";
                                  supported: "not";
                              },
                              {
                                  description: "_Handle `options`, `getOption`, ..._ Currently, we do not support the function at all.";
                                  id: "built-in-options";
                                  name: "Options";
                                  supported: "not";
                              },
                              {
                                  description: "_Handle `help`, `?`, ..._ We do not support the function in a sensible way but just ignore it (although this does not happen resolved).";
                                  id: "built-in-help";
                                  name: "Help";
                                  supported: "partially";
                              },
                              {
                                  capabilities: readonly [
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                      { description: ...; id: ...; name: ...; supported: ... },
                                  ];
                                  id: "reflection-\"computing-on-the-language\"";
                                  name: "Reflection / \"Computing on the Language\"";
                              },
                          ];
                          id: "important-built-ins";
                          name: "Important Built-Ins";
                      },
                  ];
                  id: "function-calls";
                  name: "Function Calls";
              },
              {
                  capabilities: readonly [
                      {
                          description: "_Recognize numbers like `3`, `3.14`, `NA`, float-hex, ..._";
                          id: "numbers";
                          name: "Numbers";
                          supported: "fully";
                      },
                      {
                          capabilities: readonly [
                              {
                                  description: "_Recognize raw strings like `r\"(a)\"`, ..._";
                                  id: "raw-strings";
                                  name: "Raw Strings";
                                  supported: "fully";
                              },
                          ];
                          description: "_Recognize strings like `\"a\"`, `'b'`, ..._";
                          id: "strings";
                          name: "Strings";
                          supported: "fully";
                      },
                      {
                          description: "_Recognize the logicals `TRUE` and `FALSE`, ..._";
                          id: "logical";
                          name: "Logical";
                          supported: "fully";
                      },
                      {
                          description: "_Recognize `NULL`_";
                          id: "null";
                          name: "NULL";
                          supported: "fully";
                      },
                      {
                          description: "_Recognize `Inf` and `NaN`_";
                          id: "inf-and-nan";
                          name: "Inf and NaN";
                          supported: "fully";
                      },
                  ];
                  id: "literal-values";
                  name: "Literal Values";
              },
          ];
          id: "expressions";
          name: "Expressions";
      },
      {
          capabilities: readonly [
              {
                  description: "_Handle recycling of vectors as explained in [Advanced R](https://adv-r.hadley.nz/vectors-chap.html)._ We do not support recycling.";
                  id: "recycling";
                  name: "Recycling";
                  supported: "not";
              },
              {
                  description: "_Handle vectorized operations as explained in [Advanced R](https://adv-r.hadley.nz/perf-improve.html?q=vectorised#vectorise)._ We do not support vectorized operations.";
                  id: "vectorized-operator-or-functions";
                  name: "Vectorized Operator or Functions";
                  supported: "not";
              },
              {
                  description: "_Handle hooks like [`userhooks`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/userhooks.html) and [`on.exit`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/on.exit)._ We do not support hooks.";
                  id: "hooks";
                  name: "Hooks";
                  supported: "not";
              },
              {
                  description: "_Handle the precedence of operators as explained in the [Documentation](https://rdrr.io/r/base/Syntax.html)._ We handle the precedence of operators (implicitly with the parser).";
                  id: "precedence";
                  name: "Precedence";
                  supported: "fully";
              },
              {
                  capabilities: readonly [
                      {
                          description: "_Handle [attributes](https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Attributes) like `attr`, `attributes`, ..._ We do not support attributes.";
                          id: "user-defined";
                          name: "User-Defined";
                          supported: "not";
                      },
                      {
                          description: "_Handle built-in attributes like `dim`, ..._ We do not support them.";
                          id: "built-in";
                          name: "Built-In";
                          supported: "not";
                      },
                  ];
                  id: "attributes";
                  name: "Attributes";
              },
          ];
          id: "non-standard-evaluations-semantics";
          name: "Non-Standard Evaluations/Semantics";
      },
      {
          capabilities: readonly [
              {
                  description: "_Recognize and resolve primitive types like `numeric`, `character`, ..._ We do not support typing currently.";
                  id: "types-primitive";
                  name: "Primitive";
                  supported: "not";
              },
              {
                  description: "_Recognize and resolve non-primitive/composite types._ We do not support typing currently.";
                  id: "types-non-primitive";
                  name: "Non-Primitive";
                  supported: "not";
              },
              {
                  description: "_Infer types from the code._ We do not support typing currently.";
                  id: "types-inference";
                  name: "Inference";
                  supported: "not";
              },
              {
                  description: "_Handle coercion of types._ We do not support typing currently.";
                  id: "types-coercion";
                  name: "Coercion";
                  supported: "not";
              },
              {
                  capabilities: readonly [
                      {
                          description: "_Handle S3 classes and methods as one unit (with attributes etc.). Including Dispatch and Inheritance._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
                          id: "oop-s3";
                          name: "S3";
                          supported: "not";
                          url: [{ href: "https://adv-r.hadley.nz/s3.html"; name: string }];
                      },
                      {
                          description: "_Handle S4 classes and methods as one unit. Including Dispatch and Inheritance_ We do not support typing currently and do not handle objects of these classes \"as units.\"";
                          id: "oop-s4";
                          name: "S4";
                          supported: "not";
                          url: [{ href: "https://adv-r.hadley.nz/s4.html"; name: string }];
                      },
                      {
                          description: "_Handle R6 classes and methods as one unit. Including Dispatch and Inheritance, as well as its Reference Semantics, Access Control, Finalizers, and Introspection._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
                          id: "oop-r6";
                          name: "R6";
                          supported: "not";
                          url: [{ href: "https://adv-r.hadley.nz/r6.html"; name: string }];
                      },
                      {
                          description: "_Handle R7 classes and methods as one unit. Including Dispatch and Inheritance, as well as its Reference Semantics, Validators, ..._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
                          id: "r7-s7";
                          name: "R7/S7";
                          supported: "not";
                          url: [
                              {
                                  href: "https://www.r-bloggers.com/2022/12/what-is-r7-a-new-oop-system-for-r/";
                                  name: "R7";
                              },
                              {
                                  href: "https://cran.r-project.org/web/packages/S7/index.html";
                                  name: "S7";
                              },
                          ];
                      },
                  ];
                  id: "object-oriented-programming";
                  name: "Object-Oriented Programming";
              },
          ];
          id: "types";
          name: "Types";
      },
      {
          capabilities: readonly [
              {
                  description: "_Recognize comments like `# this is a comment`, ... and line-directives_";
                  id: "comments";
                  name: "Comments";
                  supported: "fully";
              },
              {
                  description: "_Recognize and resolve semicolons like `a; b; c`, ..._";
                  id: "semicolons";
                  name: "Semicolons";
                  supported: "fully";
              },
              {
                  description: "_Recognize and resolve newlines like `a\nb\nc`, ..._";
                  id: "newlines";
                  name: "Newlines";
                  supported: "fully";
              },
          ];
          id: "structure";
          name: "Structure";
      },
      {
          capabilities: readonly [
              {
                  description: "_Handle `source`, `sys.source`, ..._ We are currently working on supporting the inclusion of external files. Currently we can handle `source`.";
                  id: "sourcing-external-files";
                  name: "Sourcing External Files";
                  supported: "partially";
              },
              {
                  description: "_Handle files dumped with, e.g., [`save`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/save), ... due to their frequent usage._ We do not support binary files.";
                  id: "handling-binary-riles";
                  name: "Handling Binary Riles";
                  supported: "not";
              },
              {
                  description: "_Handle `read.csv`, `write.csv`, ..._ We do not support I/O for the time being but treat them as unknown function calls.";
                  id: "i-o";
                  name: "I/O";
                  supported: "not";
              },
              {
                  description: "_Handle `.Fortran`, `C`,..._ We do not support FFI but treat them as unknown function calls.";
                  id: "foreign-function-interface";
                  name: "Foreign Function Interface";
                  supported: "not";
              },
              {
                  description: "_Handle [`system`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/system), `system.*`, ..._ We do not support system calls but treat them as unknown function calls.";
                  id: "system-calls";
                  name: "System Calls";
                  supported: "not";
              },
          ];
          id: "system-i-o-ffi-and-other-files";
          name: "System, I/O, FFI, and Other Files";
      },
      {
          description: "_Handle pre-processors like `knitr`, `rmarkdown`, `roxygen2` ..._ We do not support pre-processors for the time being (being unable to handle things like `@importFrom`)";
          id: "pre-processors-external-tooling";
          name: "Pre-Processors/external Tooling";
          supported: "not";
      },
  ]

• Readonlydescription: "This is an evolving representation of what started with #636 to formulate capabilities in a structured format."

• Readonlyname: "Capabilities of flowR"

• Readonlyversion: "0.0.2"