Generic operators

Operators that accept a value of any type.

Every program can use these operators. No import is necessary.

Operator	Arguments	Gives
!!	arg: <optional>T	T
!=	left: T, right: T	boolean
!null?	arg: <optional>T	boolean
??	left: <optional>T, right: T	T
[]	typeDef: T, listOf: expression	[T]
&&	left: <optional>T, right: boolean	boolean
&&	left: <optional>T, right: <optional>S	boolean
==	left: T, right: T	boolean
cast	arg: T, target: S	S
empty	node: T	&lt;optional&gt;T
null?	arg: <optional>T	boolean
ret	a: T	T
unwrap	arg: <optional>T	T
wrap	arg: T	&lt;optional&gt;T

Target support marks

• ✔Own template
• ✱Default template
• ✕No template

The operator works for a target with an own template and for a target with the default template. The default template is the * entry of the definition: it writes the same code for every target that has no template of its own. A target with no template writes no code, and a program that uses the operator does not compile for that target.

!!

(!! arg) → T

!!(arg: <optional>T)

Gives the value of the optional argument.

The program stops when the value is empty. Use ?? when the program must continue with a default value.

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✱Python: default template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Optional values

docs/examples/core/generic/optionals.rgr

class Main {
    sfn main:void () {
        def name@(optional):string
        def shown (?? name "unknown")
        print ("default " + shown)
        if (null? name) {
            print "the name is empty"
        }
        name = "Ada"
        def value (!! name)
        print ("value " + value)
    }
}

JavaScript

main function, JavaScript

let name;
const shown = (name ?? "unknown");
console.log("default " + shown);
if ( typeof(name) === "undefined" ) {
  console.log("the name is empty");
}
name = "Ada";
const value = name;
console.log("value " + value);

The complete file

class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let name;
  const shown = (name ?? "unknown");
  console.log("default " + shown);
  if ( typeof(name) === "undefined" ) {
    console.log("the name is empty");
  }
  name = "Ada";
  const value = name;
  console.log("value " + value);
}
__js_main();

TypeScript

main function, TypeScript

let name : string | undefined ;
const shown : string  = (name ?? "unknown");
console.log("default " + shown);
if ( typeof(name) === "undefined" ) {
  console.log("the name is empty");
}
name = "Ada";
const value : string  = name;
console.log("value " + value);

The complete file

export class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let name : string | undefined ;
  const shown : string  = (name ?? "unknown");
  console.log("default " + shown);
  if ( typeof(name) === "undefined" ) {
    console.log("the name is empty");
  }
  name = "Ada";
  const value : string  = name;
  console.log("value " + value);
}
__js_main();

Go

main function, Go

var name *GoNullable = new(GoNullable);
var shown string= (func() string { if name.has_value { return name.value.(string) } else { return "unknown"} }());
fmt.Println( "default " + shown )
if  !name.has_value  {
  fmt.Println( "the name is empty" )
}
name.value = "Ada";
name.has_value = true; /* detected as non-optional */
var value string= name.value.(string);
fmt.Println( "value " + value )

The complete file

package main
import (
  "fmt"
)

type GoNullable struct {
  value interface{}
  has_value bool
}

type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var name *GoNullable = new(GoNullable);
  var shown string= (func() string { if name.has_value { return name.value.(string) } else { return "unknown"} }());
  fmt.Println( "default " + shown )
  if  !name.has_value  {
    fmt.Println( "the name is empty" )
  }
  name.value = "Ada";
  name.has_value = true; /* detected as non-optional */
  var value string= name.value.(string);
  fmt.Println( "value " + value )
}

Rust

main function, Rust

let __rg_main_thread = std::thread::Builder::new().stack_size(512 * 1024 * 1024)
  .spawn(__rg_main_body).expect("could not start the main thread");
__rg_main_thread.join().expect("main thread panicked");

The complete file

#![allow(dead_code)]

#[derive(Clone)]
struct Main {
}
impl Main {
  pub fn new() -> Self {
    Self {
    }
  }
}
fn main() {
  let __rg_main_thread = std::thread::Builder::new().stack_size(512 * 1024 * 1024)
    .spawn(__rg_main_body).expect("could not start the main thread");
  __rg_main_thread.join().expect("main thread panicked");
}
fn __rg_main_body() {
  let mut name: Option<String> = None;
  let shown: String = if name.is_some() { name.clone().unwrap() } else { "unknown".to_string() };
  println!("default {}", shown);
  if  name.is_none() {
    println!("the name is empty");
  }
  name = Some("Ada".to_string());
  let value: String = name.unwrap();
  println!("value {}", value);
}

Python

main function, Python

name = None
shown = (name if (name is not None) else "unknown")
print("default " + shown)
if name is None:
  print("the name is empty")
name = "Ada";
value = name
print("value " + value)

The complete file

# -*- coding: utf-8 -*-
from __future__ import annotations
from typing import Optional



class Main:
  def __init__(self) -> None:
    pass
# Main entry point
def main():
  name = None
  shown = (name if (name is not None) else "unknown")
  print("default " + shown)
  if name is None:
    print("the name is empty")
  name = "Ada";
  value = name
  print("value " + value)
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
String name = null;
final String shown = (name != null ) ? name : "unknown";
System.out.println(String.valueOf( "default " + shown ) );
if ( name == null ) {
  System.out.println(String.valueOf( "the name is empty" ) );
}
name = "Ada";
final String value = name;
System.out.println(String.valueOf( "value " + value ) );

The complete file

import java.io.*;

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    String name = null;
    final String shown = (name != null ) ? name : "unknown";
    System.out.println(String.valueOf( "default " + shown ) );
    if ( name == null ) {
      System.out.println(String.valueOf( "the name is empty" ) );
    }
    name = "Ada";
    final String value = name;
    System.out.println(String.valueOf( "value " + value ) );
  }
}


public class RgArgs {
  public static String[] args = new String[0];
}

Kotlin

main function, Kotlin

__g_args = args
var name : String?  = null;
val shown : String  = (name ?: "unknown");
println( "default " + shown )
if ( name== null ) {
  println( "the name is empty" )
}
name = "Ada";
val value : String  = name!!;
println( "value " + value )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var name : String?  = null;
  val shown : String  = (name ?: "unknown");
  println( "default " + shown )
  if ( name== null ) {
    println( "the name is empty" )
  }
  name = "Ada";
  val value : String  = name!!;
  println( "value " + value )
}

Dart

main function, Dart

__g_args = args;
String? name = null;
String shown = (name ?? "unknown");
print( "default " + shown );
if ( name == null ) {
  print( "the name is empty" );
}
name = "Ada";
String value = name!;
print( "value " + value );

The complete file

class Main {
}

List<String> __g_args = <String>[];

void main(List<String> args) {
  __g_args = args;
  String? name = null;
  String shown = (name ?? "unknown");
  print( "default " + shown );
  if ( name == null ) {
    print( "the name is empty" );
  }
  name = "Ada";
  String value = name!;
  print( "value " + value );
}

Swift

main function, Swift

var name : String? = nil
let shown : String = (name ?? "unknown")
print("default " + shown)
if ( name == nil ) {
  print("the name is empty")
}
name = "Ada";
let value : String = name!
print("value " + value)

The complete file

func ==(l: Main, r: Main) -> Bool {
  return l === r
}
final class Main : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
}
// Main entry point
func __main__swift() {
  var name : String? = nil
  let shown : String = (name ?? "unknown")
  print("default " + shown)
  if ( name == nil ) {
    print("the name is empty")
  }
  name = "Ada";
  let value : String = name!
  print("value " + value)
}
__main__swift()

C#

main function, C#

String name = null;
String shown = (name ?? "unknown");
Console.WriteLine("default " + shown);
if ( name == null  ) {
  Console.WriteLine("the name is empty");
}
name = "Ada";
String value = name;
Console.WriteLine("value " + value);

The complete file

using System;
class Main  {
  static void Main( string [] args ) {
    String name = null;
    String shown = (name ?? "unknown");
    Console.WriteLine("default " + shown);
    if ( name == null  ) {
      Console.WriteLine("the name is empty");
    }
    name = "Ada";
    String value = name;
    Console.WriteLine("value " + value);
  }
}

C++

main function, C++

r_optional_primitive<std::string>  name;
std::string shown = (name.has_value ? name.value : std::string("unknown"));
std::cout << std::string("default ") + shown << std::endl;
if ( name.has_value == false ) {
  std::cout << std::string("the name is empty") << std::endl;
}
name  = std::string("Ada");
std::string value = name;
std::cout << std::string("value ") + value << std::endl;
return 0;

The complete file

#include  <memory>
#include  <string>
#include  <iostream>

// define classes here to avoid compiler errors
class Main;


template <class T>
class r_optional_primitive {
  public:
    // has_value has to start false: cpp_str_to_int and its siblings leave the
    // field untouched when the conversion throws, and an indeterminate bool
    // made a failed str2int read back as a value on the C++ target.
    bool has_value = false;
    T value = T();
    r_optional_primitive() {}
    // a plain value placed into an optional slot: returning a bare string
    // from a function declared @(optional):string arrives here. Declaring
    // any constructor takes the implicit default one away, hence the pair.
    r_optional_primitive(const T & a_value) : has_value(true), value(a_value) {}
    r_optional_primitive<T> & operator=(const r_optional_primitive<T> & rhs) {
        has_value = rhs.has_value;
        value = rhs.value;
        return *this;
    }
    r_optional_primitive<T> & operator=(const T a_value) {
        has_value = true;
        value = a_value;
        return *this;
    }
};



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
   r_optional_primitive<std::string>  name;
  std::string shown = (name.has_value ? name.value : std::string("unknown"));
  std::cout << std::string("default ") + shown << std::endl;
  if ( name.has_value == false ) {
    std::cout << std::string("the name is empty") << std::endl;
  }
  name  = std::string("Ada");
  std::string value = name;
  std::cout << std::string("value ") + value << std::endl;
  return 0;
}

PHP

main function, PHP

$name = null;
$shown = ($name ?? "unknown");
echo( "default " . $shown . "\n");
if ( (!isset($name)) ) {
  echo( "the name is empty" . "\n");
}
$name = "Ada";
$value = $name;
echo( "value " . $value . "\n");

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$name = null;
$shown = ($name ?? "unknown");
echo( "default " . $shown . "\n");
if ( (!isset($name)) ) {
  echo( "the name is empty" . "\n");
}
$name = "Ada";
$value = $name;
echo( "value " . $value . "\n");

Scala

main function, Scala

var name : Option[String]  = Option.empty[String]
val shown : String = (name).getOrElse("unknown")
println( "default " + shown )
if ( name.isDefined == false  ) {
  println( "the name is empty" )
}
name = Some("Ada")
val value : String = name.get
println( "value " + value )

The complete file

case class ScalaReturnValue(value:Any) extends Exception

// application main function for Main
object AppMain extends App {
  var name : Option[String]  = Option.empty[String]
  val shown : String = (name).getOrElse("unknown")
  println( "default " + shown )
  if ( name.isDefined == false  ) {
    println( "the name is empty" )
  }
  name = Some("Ada")
  val value : String = name.get
  println( "value " + value )
}

Definition: compiler/Lang.rgr, line 4288

!=

(!= left right) → boolean

!=(left: T, right: T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✱Go: default template
• ✔Rust: own template
• ✱Python: default template
• ✱Java: default template
• ✱Kotlin: default template
• ✱Dart: default template
• ✱Swift: default template
• ✱C#: default template
• ✱C++: default template
• ✱PHP: default template
• ✱Scala: default template

Definition: compiler/Lang.rgr, line 11489

!null?

(!null? arg) → boolean

!null?(arg: <optional>T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 5637

??

(?? left right) → T

??(left: <optional>T, right: T)

Gives the value of the optional argument. When that value is empty, gives the second argument.

The operator is in prefix form. Write (?? name "unknown").

Target support

• ✔JavaScript: own template
• ✔TypeScript: own template
• ✱Go: default template
• ✱Rust: default template
• ✱Python: default template
• ✱Java: default template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✱C++: default template
• ✔PHP: own template
• ✔Scala: own template

Optional values

docs/examples/core/generic/optionals.rgr

class Main {
    sfn main:void () {
        def name@(optional):string
        def shown (?? name "unknown")
        print ("default " + shown)
        if (null? name) {
            print "the name is empty"
        }
        name = "Ada"
        def value (!! name)
        print ("value " + value)
    }
}

JavaScript

main function, JavaScript

let name;
const shown = (name ?? "unknown");
console.log("default " + shown);
if ( typeof(name) === "undefined" ) {
  console.log("the name is empty");
}
name = "Ada";
const value = name;
console.log("value " + value);

The complete file

class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let name;
  const shown = (name ?? "unknown");
  console.log("default " + shown);
  if ( typeof(name) === "undefined" ) {
    console.log("the name is empty");
  }
  name = "Ada";
  const value = name;
  console.log("value " + value);
}
__js_main();

TypeScript

main function, TypeScript

let name : string | undefined ;
const shown : string  = (name ?? "unknown");
console.log("default " + shown);
if ( typeof(name) === "undefined" ) {
  console.log("the name is empty");
}
name = "Ada";
const value : string  = name;
console.log("value " + value);

The complete file

export class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let name : string | undefined ;
  const shown : string  = (name ?? "unknown");
  console.log("default " + shown);
  if ( typeof(name) === "undefined" ) {
    console.log("the name is empty");
  }
  name = "Ada";
  const value : string  = name;
  console.log("value " + value);
}
__js_main();

Go

main function, Go

var name *GoNullable = new(GoNullable);
var shown string= (func() string { if name.has_value { return name.value.(string) } else { return "unknown"} }());
fmt.Println( "default " + shown )
if  !name.has_value  {
  fmt.Println( "the name is empty" )
}
name.value = "Ada";
name.has_value = true; /* detected as non-optional */
var value string= name.value.(string);
fmt.Println( "value " + value )

The complete file

package main
import (
  "fmt"
)

type GoNullable struct {
  value interface{}
  has_value bool
}

type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var name *GoNullable = new(GoNullable);
  var shown string= (func() string { if name.has_value { return name.value.(string) } else { return "unknown"} }());
  fmt.Println( "default " + shown )
  if  !name.has_value  {
    fmt.Println( "the name is empty" )
  }
  name.value = "Ada";
  name.has_value = true; /* detected as non-optional */
  var value string= name.value.(string);
  fmt.Println( "value " + value )
}

Rust

main function, Rust

let __rg_main_thread = std::thread::Builder::new().stack_size(512 * 1024 * 1024)
  .spawn(__rg_main_body).expect("could not start the main thread");
__rg_main_thread.join().expect("main thread panicked");

The complete file

#![allow(dead_code)]

#[derive(Clone)]
struct Main {
}
impl Main {
  pub fn new() -> Self {
    Self {
    }
  }
}
fn main() {
  let __rg_main_thread = std::thread::Builder::new().stack_size(512 * 1024 * 1024)
    .spawn(__rg_main_body).expect("could not start the main thread");
  __rg_main_thread.join().expect("main thread panicked");
}
fn __rg_main_body() {
  let mut name: Option<String> = None;
  let shown: String = if name.is_some() { name.clone().unwrap() } else { "unknown".to_string() };
  println!("default {}", shown);
  if  name.is_none() {
    println!("the name is empty");
  }
  name = Some("Ada".to_string());
  let value: String = name.unwrap();
  println!("value {}", value);
}

Python

main function, Python

name = None
shown = (name if (name is not None) else "unknown")
print("default " + shown)
if name is None:
  print("the name is empty")
name = "Ada";
value = name
print("value " + value)

The complete file

# -*- coding: utf-8 -*-
from __future__ import annotations
from typing import Optional



class Main:
  def __init__(self) -> None:
    pass
# Main entry point
def main():
  name = None
  shown = (name if (name is not None) else "unknown")
  print("default " + shown)
  if name is None:
    print("the name is empty")
  name = "Ada";
  value = name
  print("value " + value)
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
String name = null;
final String shown = (name != null ) ? name : "unknown";
System.out.println(String.valueOf( "default " + shown ) );
if ( name == null ) {
  System.out.println(String.valueOf( "the name is empty" ) );
}
name = "Ada";
final String value = name;
System.out.println(String.valueOf( "value " + value ) );

The complete file

import java.io.*;

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    String name = null;
    final String shown = (name != null ) ? name : "unknown";
    System.out.println(String.valueOf( "default " + shown ) );
    if ( name == null ) {
      System.out.println(String.valueOf( "the name is empty" ) );
    }
    name = "Ada";
    final String value = name;
    System.out.println(String.valueOf( "value " + value ) );
  }
}


public class RgArgs {
  public static String[] args = new String[0];
}

Kotlin

main function, Kotlin

__g_args = args
var name : String?  = null;
val shown : String  = (name ?: "unknown");
println( "default " + shown )
if ( name== null ) {
  println( "the name is empty" )
}
name = "Ada";
val value : String  = name!!;
println( "value " + value )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var name : String?  = null;
  val shown : String  = (name ?: "unknown");
  println( "default " + shown )
  if ( name== null ) {
    println( "the name is empty" )
  }
  name = "Ada";
  val value : String  = name!!;
  println( "value " + value )
}

Dart

main function, Dart

__g_args = args;
String? name = null;
String shown = (name ?? "unknown");
print( "default " + shown );
if ( name == null ) {
  print( "the name is empty" );
}
name = "Ada";
String value = name!;
print( "value " + value );

The complete file

class Main {
}

List<String> __g_args = <String>[];

void main(List<String> args) {
  __g_args = args;
  String? name = null;
  String shown = (name ?? "unknown");
  print( "default " + shown );
  if ( name == null ) {
    print( "the name is empty" );
  }
  name = "Ada";
  String value = name!;
  print( "value " + value );
}

Swift

main function, Swift

var name : String? = nil
let shown : String = (name ?? "unknown")
print("default " + shown)
if ( name == nil ) {
  print("the name is empty")
}
name = "Ada";
let value : String = name!
print("value " + value)

The complete file

func ==(l: Main, r: Main) -> Bool {
  return l === r
}
final class Main : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
}
// Main entry point
func __main__swift() {
  var name : String? = nil
  let shown : String = (name ?? "unknown")
  print("default " + shown)
  if ( name == nil ) {
    print("the name is empty")
  }
  name = "Ada";
  let value : String = name!
  print("value " + value)
}
__main__swift()

C#

main function, C#

String name = null;
String shown = (name ?? "unknown");
Console.WriteLine("default " + shown);
if ( name == null  ) {
  Console.WriteLine("the name is empty");
}
name = "Ada";
String value = name;
Console.WriteLine("value " + value);

The complete file

using System;
class Main  {
  static void Main( string [] args ) {
    String name = null;
    String shown = (name ?? "unknown");
    Console.WriteLine("default " + shown);
    if ( name == null  ) {
      Console.WriteLine("the name is empty");
    }
    name = "Ada";
    String value = name;
    Console.WriteLine("value " + value);
  }
}

C++

main function, C++

r_optional_primitive<std::string>  name;
std::string shown = (name.has_value ? name.value : std::string("unknown"));
std::cout << std::string("default ") + shown << std::endl;
if ( name.has_value == false ) {
  std::cout << std::string("the name is empty") << std::endl;
}
name  = std::string("Ada");
std::string value = name;
std::cout << std::string("value ") + value << std::endl;
return 0;

The complete file

#include  <memory>
#include  <string>
#include  <iostream>

// define classes here to avoid compiler errors
class Main;


template <class T>
class r_optional_primitive {
  public:
    // has_value has to start false: cpp_str_to_int and its siblings leave the
    // field untouched when the conversion throws, and an indeterminate bool
    // made a failed str2int read back as a value on the C++ target.
    bool has_value = false;
    T value = T();
    r_optional_primitive() {}
    // a plain value placed into an optional slot: returning a bare string
    // from a function declared @(optional):string arrives here. Declaring
    // any constructor takes the implicit default one away, hence the pair.
    r_optional_primitive(const T & a_value) : has_value(true), value(a_value) {}
    r_optional_primitive<T> & operator=(const r_optional_primitive<T> & rhs) {
        has_value = rhs.has_value;
        value = rhs.value;
        return *this;
    }
    r_optional_primitive<T> & operator=(const T a_value) {
        has_value = true;
        value = a_value;
        return *this;
    }
};



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
   r_optional_primitive<std::string>  name;
  std::string shown = (name.has_value ? name.value : std::string("unknown"));
  std::cout << std::string("default ") + shown << std::endl;
  if ( name.has_value == false ) {
    std::cout << std::string("the name is empty") << std::endl;
  }
  name  = std::string("Ada");
  std::string value = name;
  std::cout << std::string("value ") + value << std::endl;
  return 0;
}

PHP

main function, PHP

$name = null;
$shown = ($name ?? "unknown");
echo( "default " . $shown . "\n");
if ( (!isset($name)) ) {
  echo( "the name is empty" . "\n");
}
$name = "Ada";
$value = $name;
echo( "value " . $value . "\n");

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$name = null;
$shown = ($name ?? "unknown");
echo( "default " . $shown . "\n");
if ( (!isset($name)) ) {
  echo( "the name is empty" . "\n");
}
$name = "Ada";
$value = $name;
echo( "value " . $value . "\n");

Scala

main function, Scala

var name : Option[String]  = Option.empty[String]
val shown : String = (name).getOrElse("unknown")
println( "default " + shown )
if ( name.isDefined == false  ) {
  println( "the name is empty" )
}
name = Some("Ada")
val value : String = name.get
println( "value " + value )

The complete file

case class ScalaReturnValue(value:Any) extends Exception

// application main function for Main
object AppMain extends App {
  var name : Option[String]  = Option.empty[String]
  val shown : String = (name).getOrElse("unknown")
  println( "default " + shown )
  if ( name.isDefined == false  ) {
    println( "the name is empty" )
  }
  name = Some("Ada")
  val value : String = name.get
  println( "value " + value )
}

Definition: compiler/Lang.rgr, line 4903

[]

([] typeDef listOf) → [T]

[](typeDef: T, listOf: expression)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✱Rust: default template
• ✱Python: default template
• ✔Java: own template
• ✱Kotlin: default template
• ✱Dart: default template
• ✱Swift: default template
• ✔C#: own template
• ✔C++: own template
• ✱PHP: default template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 5525

&&

(&& left right) → boolean

&&(left: <optional>T, right: boolean)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 11575

&&

(&& left right) → boolean

&&(left: <optional>T, right: <optional>S)

optional testing

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 11535

==

(== left right) → boolean

==(left: T, right: T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✱Go: default template
• ✔Rust: own template
• ✱Python: default template
• ✱Java: default template
• ✱Kotlin: default template
• ✱Dart: default template
• ✱Swift: default template
• ✱C#: default template
• ✱C++: default template
• ✱PHP: default template
• ✱Scala: default template

Definition: compiler/Lang.rgr, line 11378

cast

(cast arg target) → S

cast(arg: T, target: S)

Target support

• ✔JavaScript: own template
• ✔TypeScript: own template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 757

empty

(empty node) → <optional>T

empty(node: T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 4249

null?

(null? arg) → boolean

null?(arg: <optional>T)

Target support

• ✔JavaScript: own template
• ✔TypeScript: own template
• ✔Go: own template
• ✔Rust: own template
• ✔Python: own template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 5586

ret

(ret a) → T

ret(a: T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✱Go: default template
• ✱Rust: default template
• ✱Python: default template
• ✱Java: default template
• ✱Kotlin: default template
• ✱Dart: default template
• ✱Swift: default template
• ✱C#: default template
• ✱C++: default template
• ✱PHP: default template
• ✱Scala: default template

Definition: lib/stdops.rgr, line 10

unwrap

(unwrap arg) → T

unwrap(arg: <optional>T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✔Rust: own template
• ✱Python: default template
• ✔Java: own template
• ✔Kotlin: own template
• ✔Dart: own template
• ✔Swift: own template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 4337

wrap

(wrap arg) → <optional>T

wrap(arg: T)

Target support

• ✱JavaScript: default template
• ✱TypeScript: default template
• ✔Go: own template
• ✱Rust: default template
• ✱Python: default template
• ✔Java: own template
• ✱Kotlin: default template
• ✱Dart: default template
• ✱Swift: default template
• ✔C#: own template
• ✔C++: own template
• ✔PHP: own template
• ✔Scala: own template

Definition: compiler/Lang.rgr, line 4267