Array operators

Operators on arrays.

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

Operator	Arguments	Gives
`array_extract`	array: [T], position: int	`T`
`array_length`	array: [T]	`int`
`at`	array: [T], index: int	`T`
`clear`	array: [T]	`void`
`def`	varname: [T]	`void`
`first`	array: [T]	`T`
`for`	list: [T], item: T, indexName: int, repeat_block: block	`void`
`get`	a: [T], index: int	`<optional>T`
`has`	array: [T]	`boolean`
`indexOf`	array: [T], element: T	`int`
`insert`	array: [T], index: int, item: T	`void`
`itemAt`	array: [T], index: int	`T`
`join`	array: [string], delimiter: string	`string`
`last`	array: [T]	`T`
`last_index`	array: [T]	`int`
`length`	array: [T]	`int`
`lift`	array: [T], index: int	`<optional>T`
`make`	typeDef: [T], size: int, repeatItem: T	`[T]`
`push`	array: [T], item: T	`void`
`pushString`	array: [string], item: string	`void`
`remove`	array: [T], index: int	`void`
`remove_index`	array: [T], index: int	`void`
`removeLast`	array: [T]	`void`
`ret`	a: [T]	`[T]`
`reverse`	array: [T]	`[T]`
`set`	array: [T], index: int, value: T	`void`
`set_at`	array: [T], index: int, value: T	`void`
`size`	array: [T]	`int`
`sort`	array: [T], cb: (fn:int (left:T right:T))	`[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.

`array_extract`

(array_extract array position) → T

array_extract(array: [T], position: int)

vec.erase(vec.begin() + index);

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 10309

`array_length`

(array_length array) → int

array_length(array: [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: default template
Swift: own template
C#: own template
C++: own template
PHP: own template
Scala: own template

Definition: compiler/Lang.rgr, line 10289

`at`

(at array index) → T

at(array: [T], index: int)

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: compiler/Lang.rgr, line 10174

`clear`

(clear array) → void

clear(array: [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 10097

`def`

(def varname) → void

def(varname: [T])

TODO: could be varname@(mutable), but the compiler may not be able to determine the mutability before the code has been processed through...

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: compiler/Lang.rgr, line 4361

`first`

(first array) → T

first(array: [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: compiler/Lang.rgr, line 10163

`for`

(for list item indexName repeat_block) → void

for(list: [T], item: T, indexName: int, repeat_block: block)

T.name is a bit of a problem ??

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 5802

`get`

(get a index) → <optional>T

get(a: [T], index: int)

Target support

JavaScript: own template
TypeScript: own template
Go: default template
Rust: default template
Python: own 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 9040

`has`

(has array) → boolean

has(array: [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: compiler/Lang.rgr, line 10141

`indexOf`

(indexOf array element) → int

indexOf(array: [T], element: T)

array function derived from scala

Target support

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

Definition: compiler/Lang.rgr, line 9818

`insert`

(insert array index item) → void

insert(array: [T], index: int, item: T)

https://github.com/golang/go/wiki/SliceTricks

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 9906

`itemAt`

(itemAt array index) → T

itemAt(array: [T], index: int)

Target support

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

Add to an array and read it

class Main {
    sfn main:void () {
        def numbers:[int]
        push numbers 10
        push numbers 20
        push numbers 30
        print ("count " + (size numbers))
        print ("second " + (itemAt numbers 1))
    }
}

let numbers = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

let numbers : Array<number> | undefined  = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

export class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers : Array<number> | undefined  = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

var numbers []int64 = make([]int64, 0);
numbers = append(numbers,int64(10));
numbers = append(numbers,int64(20));
numbers = append(numbers,int64(30));
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )

The complete file

package main
import (
  "strings"
  "strconv"
  "fmt"
)

type GoNullable struct {
  value interface{}
  has_value bool
}

type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64 = make([]int64, 0);
  numbers = append(numbers,int64(10));
  numbers = append(numbers,int64(20));
  numbers = append(numbers,int64(30));
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )
}

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 numbers: Vec<i64> = Vec::new();
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  println!("count {}", numbers.len() as i64);
  println!("second {}", numbers[1]);
}

numbers = []
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + str(len(numbers)))
print("second " + str(numbers[1]))

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():
  numbers = []
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + str(len(numbers)))
  print("second " + str(numbers[1]))
if __name__ == "__main__":
  main()

RgArgs.args = args;
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
System.out.println(String.valueOf( "count " + numbers.size() ) );
System.out.println(String.valueOf( "second " + numbers.get(1) ) );

The complete file

import java.util.*;
import java.io.*;

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);
    System.out.println(String.valueOf( "count " + numbers.size() ) );
    System.out.println(String.valueOf( "second " + numbers.get(1) ) );
  }
}


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

__g_args = args
var numbers : MutableList<Int>  = arrayListOf();
numbers.add(10);
numbers.add(20);
numbers.add(30);
println( "count " + (numbers.size).toString() )
println( "second " + (numbers[1]).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var numbers : MutableList<Int>  = arrayListOf();
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  println( "count " + (numbers.size).toString() )
  println( "second " + (numbers[1]).toString() )
}

__g_args = args;
List<int> numbers = [];
numbers.add(10);
numbers.add(20);
numbers.add(30);
print( "count " + (numbers.length).toString() );
print( "second " + (numbers[1]).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [];
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  print( "count " + (numbers.length).toString() );
  print( "second " + (numbers[1]).toString() );
}

var numbers : [Int] = [Int]()
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + String(numbers.count))
print("second " + String(numbers[1]))

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 numbers : [Int] = [Int]()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + String(numbers.count))
  print("second " + String(numbers[1]))
}
__main__swift()

List<int> numbers = new List<int>();
numbers.Add(10);
numbers.Add(20);
numbers.Add(30);
Console.WriteLine("count " + numbers.Count);
Console.WriteLine("second " + numbers[1]);

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    List<int> numbers = new List<int>();
    numbers.Add(10);
    numbers.Add(20);
    numbers.Add(30);
    Console.WriteLine("count " + numbers.Count);
    Console.WriteLine("second " + numbers[1]);
  }
}

std::vector<int> numbers;
numbers.push_back( 10  );
numbers.push_back( 20  );
numbers.push_back( 30  );
std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
return 0;

The complete file

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

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



// 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;
  std::vector<int> numbers;
  numbers.push_back( 10  );
  numbers.push_back( 20  );
  numbers.push_back( 30  );
  std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
  std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
  return 0;
}

$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
numbers.append(10)
numbers.append(20)
numbers.append(30)
println( "count " + numbers.length )
println( "second " + numbers(1) )

The complete file

import scala.collection.mutable
case class ScalaReturnValue(value:Any) extends Exception

// application main function for Main
object AppMain extends App {
  var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  println( "count " + numbers.length )
  println( "second " + numbers(1) )
}

Definition: compiler/Lang.rgr, line 9324

`join`

(join array delimiter) → string

join(array: [string], delimiter: string)

scala: .mkString(

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 8958

`last`

(last array) → T

last(array: [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: compiler/Lang.rgr, line 10152

`last_index`

(last_index array) → int

last_index(array: [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: compiler/Lang.rgr, line 10147

`length`

(length array) → int

length(array: [T])

Target support

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

Definition: compiler/Lang.rgr, line 10062

`lift`

(lift array index) → <optional>T

lift(array: [T], index: int)

Target support

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

Definition: compiler/Lang.rgr, line 9312

`make`

(make typeDef size repeatItem) → [T]

make(typeDef: [T], size: int, repeatItem: T)

Target support

JavaScript: own template
TypeScript: own 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: default template

Definition: compiler/Lang.rgr, line 5509

`push`

(push array item) → void

push(array: [T], item: T)

Adds the item to the end of the array.

The array grows by one item. The operator gives no value.

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

Add to an array and read it

class Main {
    sfn main:void () {
        def numbers:[int]
        push numbers 10
        push numbers 20
        push numbers 30
        print ("count " + (size numbers))
        print ("second " + (itemAt numbers 1))
    }
}

let numbers = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

let numbers : Array<number> | undefined  = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

export class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers : Array<number> | undefined  = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

var numbers []int64 = make([]int64, 0);
numbers = append(numbers,int64(10));
numbers = append(numbers,int64(20));
numbers = append(numbers,int64(30));
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )

The complete file

package main
import (
  "strings"
  "strconv"
  "fmt"
)

type GoNullable struct {
  value interface{}
  has_value bool
}

type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64 = make([]int64, 0);
  numbers = append(numbers,int64(10));
  numbers = append(numbers,int64(20));
  numbers = append(numbers,int64(30));
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )
}

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 numbers: Vec<i64> = Vec::new();
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  println!("count {}", numbers.len() as i64);
  println!("second {}", numbers[1]);
}

numbers = []
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + str(len(numbers)))
print("second " + str(numbers[1]))

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():
  numbers = []
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + str(len(numbers)))
  print("second " + str(numbers[1]))
if __name__ == "__main__":
  main()

RgArgs.args = args;
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
System.out.println(String.valueOf( "count " + numbers.size() ) );
System.out.println(String.valueOf( "second " + numbers.get(1) ) );

The complete file

import java.util.*;
import java.io.*;

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);
    System.out.println(String.valueOf( "count " + numbers.size() ) );
    System.out.println(String.valueOf( "second " + numbers.get(1) ) );
  }
}


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

__g_args = args
var numbers : MutableList<Int>  = arrayListOf();
numbers.add(10);
numbers.add(20);
numbers.add(30);
println( "count " + (numbers.size).toString() )
println( "second " + (numbers[1]).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var numbers : MutableList<Int>  = arrayListOf();
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  println( "count " + (numbers.size).toString() )
  println( "second " + (numbers[1]).toString() )
}

__g_args = args;
List<int> numbers = [];
numbers.add(10);
numbers.add(20);
numbers.add(30);
print( "count " + (numbers.length).toString() );
print( "second " + (numbers[1]).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [];
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  print( "count " + (numbers.length).toString() );
  print( "second " + (numbers[1]).toString() );
}

var numbers : [Int] = [Int]()
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + String(numbers.count))
print("second " + String(numbers[1]))

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 numbers : [Int] = [Int]()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + String(numbers.count))
  print("second " + String(numbers[1]))
}
__main__swift()

List<int> numbers = new List<int>();
numbers.Add(10);
numbers.Add(20);
numbers.Add(30);
Console.WriteLine("count " + numbers.Count);
Console.WriteLine("second " + numbers[1]);

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    List<int> numbers = new List<int>();
    numbers.Add(10);
    numbers.Add(20);
    numbers.Add(30);
    Console.WriteLine("count " + numbers.Count);
    Console.WriteLine("second " + numbers[1]);
  }
}

std::vector<int> numbers;
numbers.push_back( 10  );
numbers.push_back( 20  );
numbers.push_back( 30  );
std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
return 0;

The complete file

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

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



// 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;
  std::vector<int> numbers;
  numbers.push_back( 10  );
  numbers.push_back( 20  );
  numbers.push_back( 30  );
  std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
  std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
  return 0;
}

$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
numbers.append(10)
numbers.append(20)
numbers.append(30)
println( "count " + numbers.length )
println( "second " + numbers(1) )

The complete file

import scala.collection.mutable
case class ScalaReturnValue(value:Any) extends Exception

// application main function for Main
object AppMain extends App {
  var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  println( "count " + numbers.length )
  println( "second " + numbers(1) )
}

Definition: compiler/Lang.rgr, line 9975

`pushString`

(pushString array item) → void

pushString(array: [string], item: string)

push for string arrays in Rust - converts &str to String `pushString` exists so that a Rust `&str` reaches a `Vec<String>`. Everywhere else it is `push`, and it has to carry the same per target spelling: the `*` fallback writes the JavaScript `.push(...)`, which is not what C++, Go, Python, Java, Kotlin, C#, PHP or Scala accept.

Target support

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

Definition: compiler/Lang.rgr, line 10004

`remove`

(remove array index) → void

remove(array: [T], index: int)

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 9926

`remove_index`

(remove_index array index) → void

remove_index(array: [T], index: int)

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 9880

`removeLast`

(removeLast array) → void

removeLast(array: [T])

think: how to release the strong array

Target support

JavaScript: default template
TypeScript: default template
Go: own template
Rust: default 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 10042

`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 5

`reverse`

(reverse array) → [T]

reverse(array: [T])

`reverse` gives a new array and leaves the argument alone -- the es6 template has always been `.slice().reverse()`. Only es6 had one, so the operator did not compile anywhere else.

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 10250

`set`

(set array index value) → void

set(array: [T], index: int, value: T)

Target support

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

Definition: compiler/Lang.rgr, line 9283

`set_at`

(set_at array index value) → void

set_at(array: [T], index: int, value: T)

Set value at specific index in array

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 9952

`size`

(size array) → int

size(array: [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

Add to an array and read it

class Main {
    sfn main:void () {
        def numbers:[int]
        push numbers 10
        push numbers 20
        push numbers 30
        print ("count " + (size numbers))
        print ("second " + (itemAt numbers 1))
    }
}

let numbers = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

let numbers : Array<number> | undefined  = [];
numbers.push(10);
numbers.push(20);
numbers.push(30);
console.log("count " + numbers.length);
console.log("second " + numbers[1]);

The complete file

export class Main  {
  constructor() {
  }
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let numbers : Array<number> | undefined  = [];
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  console.log("count " + numbers.length);
  console.log("second " + numbers[1]);
}
__js_main();

var numbers []int64 = make([]int64, 0);
numbers = append(numbers,int64(10));
numbers = append(numbers,int64(20));
numbers = append(numbers,int64(30));
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )

The complete file

package main
import (
  "strings"
  "strconv"
  "fmt"
)

type GoNullable struct {
  value interface{}
  has_value bool
}

type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64 = make([]int64, 0);
  numbers = append(numbers,int64(10));
  numbers = append(numbers,int64(20));
  numbers = append(numbers,int64(30));
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(numbers)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "second ",strconv.FormatInt(numbers[int64(1)], 10) }, "") )
}

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 numbers: Vec<i64> = Vec::new();
  numbers.push(10);
  numbers.push(20);
  numbers.push(30);
  println!("count {}", numbers.len() as i64);
  println!("second {}", numbers[1]);
}

numbers = []
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + str(len(numbers)))
print("second " + str(numbers[1]))

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():
  numbers = []
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + str(len(numbers)))
  print("second " + str(numbers[1]))
if __name__ == "__main__":
  main()

RgArgs.args = args;
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
System.out.println(String.valueOf( "count " + numbers.size() ) );
System.out.println(String.valueOf( "second " + numbers.get(1) ) );

The complete file

import java.util.*;
import java.io.*;

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);
    System.out.println(String.valueOf( "count " + numbers.size() ) );
    System.out.println(String.valueOf( "second " + numbers.get(1) ) );
  }
}


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

__g_args = args
var numbers : MutableList<Int>  = arrayListOf();
numbers.add(10);
numbers.add(20);
numbers.add(30);
println( "count " + (numbers.size).toString() )
println( "second " + (numbers[1]).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var numbers : MutableList<Int>  = arrayListOf();
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  println( "count " + (numbers.size).toString() )
  println( "second " + (numbers[1]).toString() )
}

__g_args = args;
List<int> numbers = [];
numbers.add(10);
numbers.add(20);
numbers.add(30);
print( "count " + (numbers.length).toString() );
print( "second " + (numbers[1]).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [];
  numbers.add(10);
  numbers.add(20);
  numbers.add(30);
  print( "count " + (numbers.length).toString() );
  print( "second " + (numbers[1]).toString() );
}

var numbers : [Int] = [Int]()
numbers.append(10)
numbers.append(20)
numbers.append(30)
print("count " + String(numbers.count))
print("second " + String(numbers[1]))

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 numbers : [Int] = [Int]()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  print("count " + String(numbers.count))
  print("second " + String(numbers[1]))
}
__main__swift()

List<int> numbers = new List<int>();
numbers.Add(10);
numbers.Add(20);
numbers.Add(30);
Console.WriteLine("count " + numbers.Count);
Console.WriteLine("second " + numbers[1]);

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    List<int> numbers = new List<int>();
    numbers.Add(10);
    numbers.Add(20);
    numbers.Add(30);
    Console.WriteLine("count " + numbers.Count);
    Console.WriteLine("second " + numbers[1]);
  }
}

std::vector<int> numbers;
numbers.push_back( 10  );
numbers.push_back( 20  );
numbers.push_back( 30  );
std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
return 0;

The complete file

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

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



// 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;
  std::vector<int> numbers;
  numbers.push_back( 10  );
  numbers.push_back( 20  );
  numbers.push_back( 30  );
  std::cout << std::string("count ") + std::to_string((int)(numbers.size())) << std::endl;
  std::cout << std::string("second ") + std::to_string(numbers.at(1)) << std::endl;
  return 0;
}

$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array();
array_push($numbers, 10);
array_push($numbers, 20);
array_push($numbers, 30);
echo( "count " . count($numbers) . "\n");
echo( "second " . $numbers[1] . "\n");

var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
numbers.append(10)
numbers.append(20)
numbers.append(30)
println( "count " + numbers.length )
println( "second " + numbers(1) )

The complete file

import scala.collection.mutable
case class ScalaReturnValue(value:Any) extends Exception

// application main function for Main
object AppMain extends App {
  var numbers : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
  numbers.append(10)
  numbers.append(20)
  numbers.append(30)
  println( "count " + numbers.length )
  println( "second " + numbers(1) )
}

Definition: compiler/Lang.rgr, line 10168

`sort`

(sort array cb) → [T]

sort(array: [T], cb: (fn:int (left:T right:T)))

go sort.slice... `sort` gives a new array and leaves the argument alone. It had two templates, es6 and go, so a program that sorted did not compile on any other target.

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 10184

Ranger 3.5.1 · commit f323fd4 · development build