Take out R code snippets from Embedding Languages guide

Author: olyagpl

docs/reference-manual/embedding/embed-languages.md

@@ -69,7 +69,8 @@ To use community-licensed versions instead, add the `-community` suffix to each
 To access [polyglot isolate](#polyglot-isolates) artifacts, use the `-isolate` suffix instead (for example, `js-isolate`).
 
 The artifacts `languages` and `tools` include all available languages and tools as dependencies. 
-This artifact might grow or shrink between major releases. We recommend selecting only the needed language(s) for a production deployment.
+This artifact might grow or shrink between major releases.
+We recommend selecting only the needed language(s) for a production deployment.
 
 Additionally, your _module-info.java_ file should require `org.graalvm.polyglot` when using Java modules:
 ```java
@@ -81,7 +82,7 @@ module com.mycompany.app {
 Whether your configuration can run with a Truffle runtime optimization depends on the GraalVM JDK you use.
 For further details, refer to the [Runtime Compilation section](#runtime-optimization-support).
 
-We recommend configuring polyglot embeddings using modules and the module path whenever possible. 
+We recommend configuring polyglot embeddings using modules and the module path whenever possible.
 Be aware that using `org.graalvm.polyglot` from the class path instead will enable access to unsafe APIs for all libraries on the class path.
 If the application is not yet modularized, hybrid use of the class path and module path is possible.
 For example:
@@ -124,17 +125,16 @@ You can use this application with other code examples to demonstrate more advanc
 
 Polyglot applications let you take values from one programming language and use them with other languages.
 
-Use the code example in this section with your polyglot application to show how the Polyglot API can return JavaScript, R, Ruby, or Python functions as Java values.
+Use the code example in this section with your polyglot application to show how the Polyglot API can return JavaScript, Python, or Ruby functions as Java values.
 
 {%
 include snippet-tabs
 tab1type="java" tab1id="Function_JS" tab1name="JavaScript" tab1path="embed/function_js.java"
-tab2type="java" tab2id="Function_R" tab2name="R" tab2path="embed/function_R.java"
+tab2type="java" tab2id="Function_Python" tab2name="Python" tab2path="embed/function_python.java"
 tab3type="java" tab3id="Function_Ruby" tab3name="Ruby" tab3path="embed/function_ruby.java"
-tab4type="java" tab4id="Function_Python" tab4name="Python" tab4path="embed/function_python.java"
 %}
 
- In this code:
+In this code:
 - `Value function` is a Java value that refers to a function.
 - The `eval` call parses the script and returns the guest language function.
 - The first assertion checks that the value returned by the code snippet can be executed.
@@ -152,32 +152,21 @@ Use the code example in this section with your polyglot application to show how
 {%
 include snippet-tabs
 tab1type="java" tab1id="Access_JS" tab1name="JavaScript" tab1path="embed/access_js_from_java.java"
-tab2type="java" tab2id="Access_R" tab2name="R" tab2path="embed/access_R_from_java.java"
+tab2type="java" tab2id="Access_Python" tab2name="Python" tab2path="embed/access_python_from_java.java"
 tab3type="java" tab3id="Access_Ruby" tab3name="Ruby" tab3path="embed/access_ruby_from_java.java"
-tab4type="java" tab4id="Access_Python" tab4name="Python" tab4path="embed/access_python_from_java.java"
 %}
 
- In this code:
-- `Value result` is an Object that contains three members: a number named `id`,
-a string named `text`, and an array named `arr`.
-- The first assertion verifies that the return value can contain members, which
-indicates that the value is an object-like structure.
-- The `id` variable is initialized by reading the member with the name `id` from
-the resulting object. The result is then converted to a Java `int`
-using `asInt()`.
+In this code:
+- `Value result` is an Object that contains three members: a number named `id`, a string named `text`, and an array named `arr`.
+- The first assertion verifies that the return value can contain members, which indicates that the value is an object-like structure.
+- The `id` variable is initialized by reading the member with the name `id` from the resulting object. The result is then converted to a Java `int` using `asInt()`.
 - The next assert verifies that result has a value of `42`.
-- The `text` variable is initialized using the value of the member `text`,
-which is also converted to a Java `String` using `asString()`.
-- The following assertion verifies the result value is equal to the
-Java `String` `"42"`.
+- The `text` variable is initialized using the value of the member `text`, which is also converted to a Java `String` using `asString()`.
+- The following assertion verifies the result value is equal to the Java `String` `"42"`.
 - Next the `arr` member that holds an array is read.
-- Arrays return `true` for `hasArrayElements`. R array instances can have
-members and array elements at the same time.
-- The next assertion verifies that the size of the array equals three. The
-Polyglot API supports big arrays, so the array length is of type `long`.
-- Finally we verify that the array element at index `1` equals `42`. Array
-indexing with polyglot values is always zero-based, even for languages such as
-R where indices start with one.
+- Arrays return `true` for `hasArrayElements`.
+- The next assertion verifies that the size of the array equals three. The Polyglot API supports big arrays, so the array length is of type `long`.
+- Finally we verify that the array element at index `1` equals `42`. Array indexing with polyglot values is always zero-based, even for languages where indices start with one.
 
 ## Access Java from Guest Languages
 
@@ -193,12 +182,11 @@ Use the code example in this section with your polyglot application to show how
 {%
 include snippet-tabs
 tab1type="java" tab1id="Access_Java_from_JS" tab1name="JavaScript" tab1path="embed/access_java_from_js.java"
-tab2type="java" tab2id="Access_Java_from_R" tab2name="R" tab2path="embed/access_java_from_R.java"
+tab4type="java" tab2id="Access_Java_from_Python" tab2name="Python" tab2path="embed/access_java_from_python.java"
 tab3type="java" tab3id="Access_Java_from_Ruby" tab3name="Ruby" tab3path="embed/access_java_from_ruby.java"
-tab4type="java" tab4id="Access_Java_from_Python" tab4name="Python" tab4path="embed/access_java_from_python.java"
 %}
 
- In this code:
+In this code:
 - The Java class `MyClass` has four public fields `id`, `text`, `arr`, and
 `ret42`. The fields are initialized with `42`, `"42"`, `new int[]{1, 42, 3}`, and
 lambda `() -> 42` that always returns an `int` value of `42`.
@@ -215,8 +203,7 @@ to the number `42` and the string `'42'`.
 to the number `42`. Whether arrays are accessed using 0-based or 1-based indices
 depends on the guest language. Independently of the language, the Java array
 stored in the `arr` field is always accessed using translated 0-based indices. For
-example, in the R language, arrays are 1-based so the second array element is
-accessible using index `2`. In the JavaScript and Ruby languages, the second
+example, in the JavaScript and Ruby languages, the second
 array element is at index `1`. In all language examples, the Java array is read
 from using the same index `1`.
 - The last line invokes the Java lambda that is contained in the field `ret42`
@@ -233,12 +220,11 @@ Use the code example in this section with your polyglot application to show how
 {%
 include snippet-tabs
 tab1type="java" tab1id="Lookup_Java_from_JS" tab1name="JavaScript" tab1path="embed/lookup_java_from_js.java"
-tab2type="java" tab2id="Lookup_Java_from_R" tab2name="R" tab2path="embed/lookup_java_from_R.java"
+tab2type="java" tab2id="Lookup_Java_from_Python" tab2name="Python" tab2path="embed/lookup_java_from_python.java"
 tab3type="java" tab3id="Lookup_Java_from_Ruby" tab3name="Ruby" tab3path="embed/lookup_java_from_ruby.java"
-tab4type="java" tab4id="Lookup_Java_from_Python" tab4name="Python" tab4path="embed/lookup_java_from_python.java"
 %}
 
- In this code:
+In this code:
 - A new context is created with all access enabled (`allowAllAccess(true)`).
 - A guest language script is evaluated.
 - The script looks up the Java type `java.math.BigDecimal` and stores it in a variable named `BigDecimal`.
@@ -261,12 +247,11 @@ Use the code example in this section with your polyglot application to see how y
 {%
 include snippet-tabs
 tab1type="java" tab1id="Proxy_JS" tab1name="JavaScript" tab1path="embed/proxy_js.java"
-tab2type="java" tab2id="Proxy_R" tab2name="R" tab2path="embed/proxy_R.java"
+tab2type="java" tab2id="Proxy_Python" tab2name="Python" tab2path="embed/proxy_python.java"
 tab3type="java" tab3id="Proxy_Ruby" tab3name="Ruby" tab3path="embed/proxy_ruby.java"
-tab4type="java" tab4id="Proxy_Python" tab4name="Python" tab4path="embed/proxy_python.java"
 %}
 
- In this code:
+In this code:
 - The Java class `ComputedArray` implements the proxy interface `ProxyArray` so
 that guest languages treat instances of the Java class-like arrays.
 - `ComputedArray` array overrides the method `get` and computes the value
@@ -279,7 +264,7 @@ an `UnsupportedOperationException` in the implementation of `set`.
 - The guest language script imports the `arr` symbol, which returns the
 exported proxy.
 - The second element and the `1000000000`th element is accessed, summed up, and
-then returned. Note that array indices from 1-based languages such as R are
+then returned. Note that array indices from 1-based languages are
 converted to 0-based indices for proxy arrays.
 - The result of the language script is returned as a long value and verified.
 
@@ -295,15 +280,15 @@ These restrictions can be lifted entirely by setting `allowAllAccess` to `true`.
 ### Controlling Access to Host Functions
 
 It might be desirable to limit the access of guest applications to the host.
-For example, if a Java method is exposed that calls `System.exit` then the guest application will be able to exit the host process.
+For example, if a Java method is exposed that calls `System.exit`, then the guest application will be able to exit the host process.
 In order to avoid accidentally exposed methods, no host access is allowed by default and every public method or field needs to be annotated with `@HostAccess.Export` explicitly.
 
 {%
 include snippet-tabs
 tab1type="java" tab1id="ExplicitHostAccess_js" tab1name="JavaScript" tab1path="embed/explicit_access_java_from_js.java"
 %}
 
- In this code:
+In this code:
 - The class `Employee` is declared with a field `name` of type `String`. Access to the `getName` method is explicitly allowed by annotating the method with `@HostAccess.Export`.
 - The `Services` class exposes two methods, `createEmployee` and `exitVM`. The `createEmployee` method takes the name of the employee as an argument and creates a new `Employee` instance. The `createEmployee` method is annotated with `@HostAccess.Export` and therefore accessible to the guest application. The `exitVM` method is not explicitly exported and therefore not accessible.
 - The `main` method first creates a new polyglot context in the default configuration, disallowing host access except for methods annotated with `@HostAccess.Export`.
@@ -708,9 +693,8 @@ For example, a dependency on isolated JavaScript can be configured by adding a M
 ```
 
 Starting from the Polyglot API version 24.1.0, the polyglot engine supports polyglot isolates for individual platforms.
-To download a polyglot isolate for a specific platform, append the operating system and
-CPU architecture classifiers to the polyglot isolate Maven `artifactId`. For example,
-to configure a dependency on isolated Python for Linux amd64, add the following Maven dependencies:
+To download a polyglot isolate for a specific platform, append the operating system and CPU architecture classifiers to the polyglot isolate Maven `artifactId`.
+For example, to configure a dependency on isolated Python for Linux amd64, add the following Maven dependencies:
 
 ```xml
 <dependency>
@@ -734,9 +718,7 @@ Supported platform classifiers are:
 * `darwin-aarch64`
 * `windows-amd64`
 
-For a complete Maven POM file that adds the polyglot isolate Native Image dependency for the current platform,
-refer to the [Polyglot Embedding Demonstration](https://github.com/graalvm/polyglot-embedding-demo) on GitHub.
-
+For a complete Maven POM file that adds the polyglot isolate Native Image dependency for the current platform, refer to the [Polyglot Embedding Demonstration](https://github.com/graalvm/polyglot-embedding-demo) on GitHub.
 
 To enable isolate usage with the Polyglot API, the `--engine.SpawnIsolate=true` option must be passed to `Engine` or `Context` when constructed.
 The option `engine.SpawnIsolate` may not be available if used on any JDK other than Oracle GraalVM.
@@ -834,7 +816,7 @@ In Linux environments that support Memory Protection Keys, the `--engine.MemoryP
 If an engine is created with this option, a dedicated protection key will be allocated for the isolated engine's heap.
 GraalVM only enables access to the engine's heap when executing code of the Polyglot Isolate.
 
-## Embed Guest Languages in Java
+## Embed a Guest Language in Java
 
 The GraalVM Polyglot API can be used from within a guest language using Java interoperability.
 This can be useful if a script needs to run isolated from the parent context.
@@ -911,7 +893,7 @@ for (;;) {
 
 ## Step Through with Execution Listeners
 
-The GraalVM Polyglot API allows users to instrument the execution of guest languages through [ExecutionListener class](http://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/management/ExecutionListener.html).
+The GraalVM Polyglot API allows users to instrument the execution of guest languages through the [ExecutionListener class](http://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/management/ExecutionListener.html).
 For example, it lets you attach an execution listener that is invoked for every statement of the guest language program.
 Execution listeners are designed as simple API for polyglot embedders and may become handy in, for example, single-stepping through the program.