stdlib.rgr

Extra library operators for arrays, maps and vectors: map, filter, reduce, any, all, slice. Also the case and cast operators for union type values.

To use these operators, add the import to the program:

Import "stdlib.rgr"

Source: lib/stdlib.rgr.

This file holds two operator mechanisms. The template operators write target code from a string per language. The type methods are Ranger code. The compiler compiles them for every target that loads the library.

Template operators

Operator	Arguments	Gives
case	arg: T, item2: boolean, code: block	void
case	arg: T, item2: double, code: block	void
case	arg: T, item2: int, code: block	void
case	arg: T, item2: JSONArrayObject, code: block	void
case	arg: T, item2: JSONDataObject, code: block	void
case	arg: T, item2: string, code: block	void
case	arg: T, item: T, code: block	void
cast	arg: T, target: Any	Any
identical	a: T, b: T	boolean
is	arg: T, item: T	boolean
to	to: T, item: 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.

case

(case arg item2 code) → void

case(arg: T, item2: boolean, code: block)

Target support

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

Definition: lib/stdlib.rgr, line 17

case

(case arg item2 code) → void

case(arg: T, item2: double, code: block)

Target support

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

Definition: lib/stdlib.rgr, line 125

case

(case arg item2 code) → void

case(arg: T, item2: int, code: block)

Target support

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

Definition: lib/stdlib.rgr, line 68

case

(case arg item2 code) → void

case(arg: T, item2: JSONArrayObject, code: block)

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: lib/stdlib.rgr, line 361

case

(case arg item2 code) → void

case(arg: T, item2: JSONDataObject, code: block)

A member of a system union -- the JSON unions over JSONDataObject and JSONArrayObject -- is an ordinary object of the target language. It carries no shape tag, so the generic overload below, which narrows on __rg_kind / _rg_kind / .tag, can never be true for one. These two overloads keep the class test that a system union needs; the generic overload keeps the tag test that a shape case needs. Every `@serialize` deserializer emits `case item oo:JSONDataObject`, so without these the reader of an array of objects reads nothing.

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: lib/stdlib.rgr, line 251

case

(case arg item2 code) → void

case(arg: T, item2: string, code: block)

Target support

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

Definition: lib/stdlib.rgr, line 183

case

(case arg item code) → void

case(arg: T, item: T, code: block)

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: lib/stdlib.rgr, line 471

cast

(cast arg target) → Any

cast(arg: T, target: Any)

Target support

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

Definition: lib/stdlib.rgr, line 11

identical

(identical a b) → boolean

identical(a: T, b: T)

Reference identity: are these two names the same object? `==` means something different on every target — structural on Kotlin, a trait bound on Rust, pointer on C++ — so identity gets its own operator rather than a per-target reading of equality. Used by the generated equality of a shape's `@(reference)` cases (PLAN_SHAPES.md S4), and useful on its own.

Target support

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

Definition: lib/stdlib.rgr, line 626

is

(is arg item) → boolean

is(arg: T, item: T)

`is v Shape.Case` — the kind test of `case` with the binding and the block taken away. `case v x:Shape.Case { … }` answers "is it this case?" and then hands the arm a narrowed `x`; an arm that only wants the answer pays for a binding it never reads. On Rust that binding costs a `.clone()` of the scrutinee (a refcount pair for every reference case), on Go a declared-and-discarded local, on ES6/Python a dead assignment. This is an expression, so it composes: `return (is self EvalValue.Number)` replaces the whole `case self n:… { return true } return false` shape. Every template below is the same discriminant test the `case` operator above already lowers to on that target — nothing new is invented, and no target evaluates (e 1) more than once.

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: lib/stdlib.rgr, line 590

to

(to to item) → T

to(to: T, item: 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/stdlib.rgr, line 643

Type methods

A type method is an operator of the receiver type. The call is receiver.name(…). The body is Ranger code, so the compiler writes it for every target that compiles the library.

[string:T]

Method	Arguments	Gives	Targets
forEach	cb: (fn:void (item:T index:string))	void	every target
forKeys	cb: (fn:void (index:string))	void	every target
get_or	key: string, fallback: T	T	every target
map_length	—	int	every target
values	—	[T]	every target

forEach

receiver.forEach(cb) → void

forEach(cb: (fn:void (item:T index:string)))

The compiler writes this method for every target.

The Ranger source of the method

fn forEach:void (cb:(_:void (item:T index:string )) ) {
    def list (keys self)
    for list kk:string i {
        def value (unwrap (get self kk))
        cb( value kk )
    }
}

Definition: lib/stdlib.rgr, line 664

forKeys

receiver.forKeys(cb) → void

forKeys(cb: (fn:void (index:string)))

The compiler writes this method for every target.

The Ranger source of the method

fn forKeys:void (cb:(_:void (index:string))) {
    def list (keys self)
    for list it:string i {
        cb(it)
    }
}

Definition: lib/stdlib.rgr, line 671

get_or

receiver.get_or(key fallback) → T

get_or(key: string, fallback: T)

Value at `key`, or `fallback` when absent

The compiler writes this method for every target.

Values, size and default value of a map

docs/examples/lib/stdlib/map-helpers.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def ages:[string:int]
        set ages "ada" 36
        set ages "alan" 41
        def all_ages (ages.values())
        print ("count " + (array_length all_ages))
        print ("keys " + (ages.map_length()))
        print ("grace " + (ages.get_or("grace" 0)))
    }
}

JavaScript

main function, JavaScript

let ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.values_2 = function(__self) {
  let res = [];
  const list = Object.keys(__self);
  for ( const kk of list) {
    res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
  }
  return res;
};
operatorsOf.mapc95length_2 = function(__self) {
  const list_1 = Object.keys(__self);
  return list_1.length;
};
operatorsOf.getc95or_3 = function(__self, key, fallback) {
  if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
    return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
  }
  return fallback;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

TypeScript

main function, TypeScript

let ages : {[key:string]:number} | undefined  = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages : Array<number>  = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static values_2 (__self : {[key:string]:number}) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const list : Array<string>  = Object.keys(__self);
    for ( const kk of list) {
      res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
    }
    return res;
  };
  static mapc95length_2 (__self : {[key:string]:number}) : number  {
    const list_1 : Array<string>  = Object.keys(__self);
    return list_1.length;
  };
  static getc95or_3 (__self : {[key:string]:number}, key : string, fallback : number) : number  {
    if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
      return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
    }
    return fallback;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages : {[key:string]:number} | undefined  = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages : Array<number>  = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

Go

main function, Go

var ages map[string]int64 = make(map[string]int64);
ages["ada"] = int64(36);
ages["alan"] = int64(41);
var all_ages []int64= operatorsOf_static_values_2(ages);
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )

The complete file

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

type GoNullable struct {
  value interface{}
  has_value bool
}

func r_get_string_int64( a map[string]int64, key string ) *GoNullable  {
  res := new(GoNullable)
  v, ok := a[key]
  if ok {
    res.has_value = true
    res.value = v
    return res
  }
  res.has_value = false
  return res
}
func r_has_key_string_int64( a map[string]int64, key string ) bool {
  _, ok := a[key]
  return ok

}
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var ages map[string]int64 = make(map[string]int64);
  ages["ada"] = int64(36);
  ages["alan"] = int64(41);
  var all_ages []int64= operatorsOf_static_values_2(ages);
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
  fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_values_2(__self map[string]int64) []int64 {
  var res []int64 = make([]int64, 0);
  var list []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  for _, kk := range list {
    res = append(res,r_get_string_int64(__self, kk).value.(int64));
  }
  return res
}
func operatorsOf_static_mapc95length_2(__self map[string]int64) int64 {
  var list_1 []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  return int64(len(list_1))
}
func operatorsOf_static_getc95or_3(__self map[string]int64, key string, fallback int64) int64 {
  if  r_has_key_string_int64(__self, key) {
    return r_get_string_int64(__self, key).value.(int64)
  }
  return fallback
}

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)]
#![allow(unused_mut)]

// FxHash (rustc-hash style): these maps are keyed by short program
// strings; SipHash's DoS resistance cost ~14% of all instructions in
// map-heavy code. Swap back to std's default by deleting the alias.
#[derive(Default, Clone)]
struct FxHasher { hash: u64 }
impl std::hash::Hasher for FxHasher {
    #[inline]
    fn write(&mut self, bytes: &[u8]) {
        const SEED: u64 = 0x517cc1b727220a95;
        let mut b = bytes;
        while b.len() >= 8 {
            let v = u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
            self.hash = (self.hash.rotate_left(5) ^ v).wrapping_mul(SEED);
            b = &b[8..];
        }
        for &x in b {
            self.hash = (self.hash.rotate_left(5) ^ (x as u64)).wrapping_mul(SEED);
        }
    }
    #[inline]
    fn finish(&self) -> u64 { self.hash }
}
// Insertion-ordered map (mirrors the C++ rg_ordered_map): entries in a
// vector plus an open-addressed FxHash index. Lookups hash once; keys()
// iterates in INSERTION order, which is what JS key enumeration needs.
// Aliased over the HashMap name so declarations stay untouched.
#[derive(Clone)]
struct RgOrderedMap<K, V> {
    entries: Vec<(K, V)>,
    index: Vec<i32>,
}
impl<K, V> Default for RgOrderedMap<K, V> {
    fn default() -> Self { RgOrderedMap { entries: Vec::new(), index: Vec::new() } }
}
impl<K, V> IntoIterator for RgOrderedMap<K, V> {
    type Item = (K, V);
    type IntoIter = std::vec::IntoIter<(K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.into_iter() }
}
impl<'a, K, V> IntoIterator for &'a RgOrderedMap<K, V> {
    type Item = &'a (K, V);
    type IntoIter = std::slice::Iter<'a, (K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.iter() }
}
impl<K: std::hash::Hash + Eq, V> RgOrderedMap<K, V> {
    fn rg_hash<Q: std::hash::Hash + ?Sized>(k: &Q) -> u64 {
        let mut h = FxHasher::default();
        k.hash(&mut h);
        std::hash::Hasher::finish(&h)
    }
    fn slot<Q>(&self, k: &Q) -> i32 where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        if self.index.is_empty() { return -1; }
        let mask = self.index.len() - 1;
        let mut h = (Self::rg_hash(k) as usize) & mask;
        loop {
            let s = self.index[h];
            if s == -1 { return -1; }
            if self.entries[s as usize].0.borrow() == k { return s; }
            h = (h + 1) & mask;
        }
    }
    fn rehash(&mut self) {
        let mut cap = 8usize;
        while cap < (self.entries.len() + 1) * 2 { cap <<= 1; }
        self.index.clear();
        self.index.resize(cap, -1);
        for i in 0..self.entries.len() {
            let mut h = (Self::rg_hash(&self.entries[i].0) as usize) & (cap - 1);
            while self.index[h] != -1 { h = (h + 1) & (cap - 1); }
            self.index[h] = i as i32;
        }
    }
    fn insert(&mut self, k: K, v: V) -> Option<V> {
        let s = self.slot(&k);
        if s != -1 { return Some(std::mem::replace(&mut self.entries[s as usize].1, v)); }
        self.entries.push((k, v));
        if self.index.is_empty() || (self.entries.len() + 1) * 2 > self.index.len() {
            self.rehash();
        } else {
            let mask = self.index.len() - 1;
            let mut h = (Self::rg_hash(&self.entries[self.entries.len() - 1].0) as usize) & mask;
            while self.index[h] != -1 { h = (h + 1) & mask; }
            self.index[h] = (self.entries.len() - 1) as i32;
        }
        None
    }
    fn get<Q>(&self, k: &Q) -> Option<&V> where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        let s = self.slot(k);
        if s == -1 { None } else { Some(&self.entries[s as usize].1) }
    }
    fn contains_key<Q>(&self, k: &Q) -> bool where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        self.slot(k) != -1
    }
    fn keys(&self) -> impl Iterator<Item = &K> { self.entries.iter().map(|e| &e.0) }
    fn len(&self) -> usize { self.entries.len() }
    fn clear(&mut self) {
        self.entries.clear();
        for s in self.index.iter_mut() { *s = -1; }
    }
}
type HashMap<K, V> = RgOrderedMap<K, V>;

#[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 ages: HashMap<String,i64> = HashMap::default();
  ages.insert("ada".to_string(), 36);
  ages.insert("alan".to_string(), 41);
  let mut all_ages: Vec<i64> = operatorsOf::values_2(&ages);
  println!("count {}", all_ages.len() as i64);
  println!("keys {}", operatorsOf::mapc95length_2(&ages));
  println!("grace {}", operatorsOf::getc95or_3(&ages, "grace", 0));
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn values_2(__self: &HashMap<String,i64>) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let mut list: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    for kk in list.iter().cloned() {
      res.push(__self.get(&kk).cloned().unwrap());
    }
    res.clone()
  }
  pub fn mapc95length_2(__self: &HashMap<String,i64>) -> i64 {
    let mut list_1: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    list_1.len() as i64
  }
  pub fn getc95or_3(__self: &HashMap<String,i64>, key: &str, fallback: i64) -> i64 {
    if  __self.contains_key(key) {
      return __self.get(key).cloned().unwrap();
    }
    fallback
  }
}

Python

main function, Python

ages = {}
ages["ada"] = 36;
ages["alan"] = 41;
all_ages = operatorsOf.values_2(ages)
print("count " + str(len(all_ages)))
print("keys " + str(operatorsOf.mapc95length_2(ages)))
print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))

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():
  ages = {}
  ages["ada"] = 36;
  ages["alan"] = 41;
  all_ages = operatorsOf.values_2(ages)
  print("count " + str(len(all_ages)))
  print("keys " + str(operatorsOf.mapc95length_2(ages)))
  print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def values_2(__self: dict[str, int]) -> list[int]:
    res = []
    _list = list(__self.keys())
    for kk in _list:
      res.append(__self.get(kk))
    return res;
  @staticmethod
  def mapc95length_2(__self: dict[str, int]) -> int:
    list_1 = list(__self.keys())
    return len(list_1);
  @staticmethod
  def getc95or_3(__self: dict[str, int], key: str, fallback: int) -> int:
    if key in __self:
      return __self.get(key);
    return fallback;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
HashMap<String,Integer> ages = new HashMap<String,Integer>();
ages.put("ada", 36);
ages.put("alan", 41);
final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
System.out.println(String.valueOf( "count " + all_ages.size() ) );
System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    HashMap<String,Integer> ages = new HashMap<String,Integer>();
    ages.put("ada", 36);
    ages.put("alan", 41);
    final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
    System.out.println(String.valueOf( "count " + all_ages.size() ) );
    System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
    System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );
  }
}


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


import java.util.*;

public class operatorsOf {

  public static ArrayList<Integer> values_2( final HashMap<String,Integer> __self ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final ArrayList<String> list = new ArrayList<>(__self.keySet());
    for ( String kk : list) {
      res.add(__self.get(kk));
    }
    return res;
  }

  public static Integer mapc95length_2( final HashMap<String,Integer> __self ) {
    final ArrayList<String> list_1 = new ArrayList<>(__self.keySet());
    return list_1.size();
  }

  public static Integer getc95or_3( final HashMap<String,Integer> __self , final String key , final Integer fallback ) {
    if ( __self.containsKey(key) ) {
      return __self.get(key);
    }
    return fallback;
  }
}

Kotlin

main function, Kotlin

__g_args = args
var ages : MutableMap<String,Int>  = hashMapOf();
ages.set("ada", 36)
ages.set("alan", 41)
val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
println( "count " + (all_ages.size).toString() )
println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var ages : MutableMap<String,Int>  = hashMapOf();
  ages.set("ada", 36)
  ages.set("alan", 41)
  val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
  println( "count " + (all_ages.size).toString() )
  println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
  println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )
}

class operatorsOf
 {
  companion object {

    fun  values_2( __self : MutableMap<String,Int>) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val list : MutableList<String>  = ArrayList(__self.keys);
      for ( kk in list ) {
        res.add(__self[kk]!!);
      }
      return res;
    }

    fun  mapc95length_2( __self : MutableMap<String,Int>) : Int {
      val list_1 : MutableList<String>  = ArrayList(__self.keys);
      return list_1.size;
    }

    fun  getc95or_3( __self : MutableMap<String,Int>, key : String, fallback : Int) : Int {
      if ( __self.containsKey(key) ) {
        return __self[key]!!;
      }
      return fallback;
    }
  }
}

Dart

main function, Dart

__g_args = args;
Map<String, int> ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
print( "count " + (all_ages.length).toString() );
print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  Map<String, int> ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  List<int> all_ages = operatorsOf.values_2(ages);
  print( "count " + (all_ages.length).toString() );
  print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
  print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );
}

class operatorsOf {

  static List<int> values_2(Map<String, int> __self) {
    List<int> res = [];
    List<String> list = __self.keys.toList();
    for ( final kk in list) {
      res.add(__self[kk]!);
    }
    return res;
  }

  static int mapc95length_2(Map<String, int> __self) {
    List<String> list_1 = __self.keys.toList();
    return list_1.length;
  }

  static int getc95or_3(Map<String, int> __self, String key, int fallback) {
    if ( __self.containsKey(key) ) {
      return __self[key]!;
    }
    return fallback;
  }
}

Swift

main function, Swift

var ages : [String:Int] = [String:Int]()
ages["ada"] = 36;
ages["alan"] = 41;
let all_ages : [Int] = operatorsOf.values_2(__self : ages)
print("count " + String(all_ages.count))
print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func values_2(__self : [String:Int]) -> [Int] {
    var res : [Int] = [Int]()
    let list : [String] = Array(__self.keys)
    for kk in list {
      res.append(__self[kk]!)
    }
    return res
  }
  class func mapc95length_2(__self : [String:Int]) -> Int {
    let list_1 : [String] = Array(__self.keys)
    return list_1.count
  }
  class func getc95or_3(__self : [String:Int], key : String, fallback : Int) -> Int {
    if ( __self[key] != nil ) {
      return __self[key]!
    }
    return fallback
  }
}
// Main entry point
func __main__swift() {
  var ages : [String:Int] = [String:Int]()
  ages["ada"] = 36;
  ages["alan"] = 41;
  let all_ages : [Int] = operatorsOf.values_2(__self : ages)
  print("count " + String(all_ages.count))
  print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
  print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))
}
__main__swift()

C#

main function, C#

Dictionary<String,int> ages = new Dictionary<String,int>();
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
Console.WriteLine("count " + all_ages.Count);
Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    Dictionary<String,int> ages = new Dictionary<String,int>();
    ages["ada"] = 36;
    ages["alan"] = 41;
    List<int> all_ages = operatorsOf.values_2(ages);
    Console.WriteLine("count " + all_ages.Count);
    Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
    Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
  }
}
class operatorsOf  {
  public static List<int> values_2( Dictionary<String,int> __self ) {
    List<int> res = new List<int>();
    List<String> list = new List<String>(__self.Keys);
    foreach ( String kk in list) {
      res.Add(((__self.ContainsKey(kk) ? (int?)__self[kk] : null)).Value);
    }
    return res;
  }
  public static int mapc95length_2( Dictionary<String,int> __self ) {
    List<String> list_1 = new List<String>(__self.Keys);
    return list_1.Count;
  }
  public static int getc95or_3( Dictionary<String,int> __self , String key , int fallback ) {
    if ( __self.ContainsKey(key) ) {
      return ((__self.ContainsKey(key) ? (int?)__self[key] : null)).Value;
    }
    return fallback;
  }
}

C++

main function, C++

rg_ordered_map<std::string,int> ages;
ages["ada"] = 36;
ages["alan"] = 41;
std::vector<int> all_ages = operatorsOf::values_2(ages);
std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
return 0;

The complete file

#include  <memory>
#include  <string_view>
#include  <vector>
#include  <cstring>
#include  <stdexcept>
#include  <map>
#include  <iostream>
#include  <string>

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


template< typename M >
std::vector<std::string> r_get_keys_of_map( const M & orig_map )  {
    std::vector<std::string> res;
    for(auto it = orig_map.begin(); it != orig_map.end(); ++it) {
        res.push_back(it->first);
    }
    return res;
}

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;
    }
};


template<typename M, typename K>
r_optional_primitive<int> cpp_get_map_int_value( const M & m , const K & key) {
r_optional_primitive<int> result;
result.has_value = false;
auto it = m.find(key);
if (it != m.end()) {
result.value = it->second;
result.has_value = true;
}
return result;
};

// String hashing for the map below. std::hash<std::string> is
// _Hash_bytes, an out-of-line MurmurHash in libstdc++ that costs a call
// and a per-byte mix; profiling the interpreter put it at ~10% of all
// instructions, since every scope lookup and every property read hashes
// a name. This is FxHash -- the one rustc uses for its own identifier
// maps -- which consumes 8 bytes per multiply-rotate and inlines.
//
// The string and string_view paths MUST agree, because the const char*
// overloads probe the same index; they share this one function, so they
// agree by construction rather than by the standard's promise about
// hash<string> and hash<string_view>.
static inline size_t rg_hash_bytes(const char* p, size_t n) {
    const size_t K = (size_t)0x517cc1b727220a95ULL;
    size_t h = n;
    size_t i = 0;
    while (n - i >= sizeof(size_t)) {
        size_t w; std::memcpy(&w, p + i, sizeof(size_t));
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ w; h *= K;
        i += sizeof(size_t);
    }
    while (i < n) {
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ (size_t)(unsigned char)p[i]; h *= K;
        i++;
    }
    return h;
}
// Any other key type keeps the standard hash; only strings are hot.
template<typename K> struct rg_key_hash {
    size_t operator()(const K& k) const { return std::hash<K>{}(k); }
};
template<> struct rg_key_hash<std::string> {
    size_t operator()(const std::string& s) const { return rg_hash_bytes(s.data(), s.size()); }
};
// Insertion-ordered map: vector storage + open-addressed hash index.
// Replaces std::map (sorted, O(log n) with a string compare per level):
// lookups hash once, and iteration follows INSERTION order, which is
// what JavaScript object key enumeration semantics need.
template<typename K, typename V>
class rg_ordered_map {
public:
    typedef K key_type;
    typedef V mapped_type;
    std::vector<std::pair<K, V>> entries;
    std::vector<int32_t> index_;
    typedef typename std::vector<std::pair<K, V>>::iterator iterator;
    typedef typename std::vector<std::pair<K, V>>::const_iterator const_iterator;
    iterator begin() { return entries.begin(); }
    iterator end() { return entries.end(); }
    const_iterator begin() const { return entries.begin(); }
    const_iterator end() const { return entries.end(); }
    size_t size() const { return entries.size(); }
    void clear() { entries.clear(); index_.clear(); }
    void rehash_() {
        size_t cap = 8;
        while (cap < (entries.size() + 1) * 2) { cap <<= 1; }
        index_.assign(cap, -1);
        for (size_t i = 0; i < entries.size(); i++) {
            size_t h = rg_key_hash<K>{}(entries[i].first) & (cap - 1);
            while (index_[h] != -1) { h = (h + 1) & (cap - 1); }
            index_[h] = (int32_t)i;
        }
    }
    int32_t slot_(const K& k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_key_hash<K>{}(k) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first == k) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const K& k) const { return slot_(k) == -1 ? 0 : 1; }
    iterator find(const K& k) {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const K& k) const {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const K& k) {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const K& k) const {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    // const char* overloads: a literal key probes WITHOUT constructing a
    // std::string temporary. C++17 guarantees hash<string> and
    // hash<string_view> agree on equal character sequences. Instantiated
    // lazily, so non-string-keyed maps never touch them.
    int32_t slot_sv_(std::string_view k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_hash_bytes(k.data(), k.size()) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first.compare(k) == 0) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const char* k) const { return slot_sv_(k) == -1 ? 0 : 1; }
    iterator find(const char* k) {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const char* k) const {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const char* k) {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const char* k) const {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    V& operator[](const char* k) {
        int32_t s = slot_sv_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        return (*this)[K(k)];
    }
    V& operator[](const K& k) {
        int32_t s = slot_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        entries.push_back(std::make_pair(k, V()));
        if (index_.empty() || (entries.size() + 1) * 2 > index_.size()) {
            rehash_();
        } else {
            size_t mask = index_.size() - 1;
            size_t h = rg_key_hash<K>{}(k) & mask;
            while (index_[h] != -1) { h = (h + 1) & mask; }
            index_[h] = (int32_t)(entries.size() - 1);
        }
        return entries.back().second;
    }
};

// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static std::vector<int> values_2( const rg_ordered_map<std::string,int>& __self );
    static int mapc95length_2( const rg_ordered_map<std::string,int>& __self );
    static int getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  rg_ordered_map<std::string,int> ages;
  ages["ada"] = 36;
  ages["alan"] = 41;
  std::vector<int> all_ages = operatorsOf::values_2(ages);
  std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
  std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
  std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
std::vector<int>  operatorsOf::values_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<int> res;
  std::vector<std::string> list = r_get_keys_of_map(__self);
  for ( const std::string& kk : list ) {
    res.push_back( /*unwrap int*/cpp_get_map_int_value(__self, kk).value  );
  }
  return res;
}
int  operatorsOf::mapc95length_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<std::string> list_1 = r_get_keys_of_map(__self);
  return (int)(list_1.size());
}
int  operatorsOf::getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback ) {
  if ( __self.count(key) > 0 ) {
    return /*unwrap int*/cpp_get_map_int_value(__self, key).value;
  }
  return fallback;
}

PHP

main function, PHP

$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

Scala

main function, Scala

var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
ages.put("ada", 36)
ages.put("alan", 41)
val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
println( "count " + all_ages.length )
println( "keys " + operatorsOf.mapc95length_2(ages) )
println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  values_2( __self : collection.mutable.HashMap[String, Int]) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val list : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    for( kk <- list ) {
      res.append(__self.get(kk).get)
    }
    return res
  }
  def  mapc95length_2( __self : collection.mutable.HashMap[String, Int]) : Int = {
    val list_1 : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    return list_1.length
  }
  def  getc95or_3( __self : collection.mutable.HashMap[String, Int], key : String, fallback : Int) : Int = {
    if ( __self.contains(key) ) {
      return __self.get(key).get
    }
    return fallback
  }
}

// application main function for Main
object AppMain extends App {
  var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
  ages.put("ada", 36)
  ages.put("alan", 41)
  val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
  println( "count " + all_ages.length )
  println( "keys " + operatorsOf.mapc95length_2(ages) )
  println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )
}

The Ranger source of the method

fn get_or:T (key:string fallback:T) @doc('Value at `key`, or `fallback` when absent') {
    if( has self key ) {
        return (unwrap (get self key))
    }
    return fallback
}

Definition: lib/stdlib.rgr, line 692

map_length

receiver.map_length() → int

Number of keys in the map

The compiler writes this method for every target.

Values, size and default value of a map

docs/examples/lib/stdlib/map-helpers.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def ages:[string:int]
        set ages "ada" 36
        set ages "alan" 41
        def all_ages (ages.values())
        print ("count " + (array_length all_ages))
        print ("keys " + (ages.map_length()))
        print ("grace " + (ages.get_or("grace" 0)))
    }
}

JavaScript

main function, JavaScript

let ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.values_2 = function(__self) {
  let res = [];
  const list = Object.keys(__self);
  for ( const kk of list) {
    res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
  }
  return res;
};
operatorsOf.mapc95length_2 = function(__self) {
  const list_1 = Object.keys(__self);
  return list_1.length;
};
operatorsOf.getc95or_3 = function(__self, key, fallback) {
  if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
    return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
  }
  return fallback;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

TypeScript

main function, TypeScript

let ages : {[key:string]:number} | undefined  = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages : Array<number>  = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static values_2 (__self : {[key:string]:number}) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const list : Array<string>  = Object.keys(__self);
    for ( const kk of list) {
      res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
    }
    return res;
  };
  static mapc95length_2 (__self : {[key:string]:number}) : number  {
    const list_1 : Array<string>  = Object.keys(__self);
    return list_1.length;
  };
  static getc95or_3 (__self : {[key:string]:number}, key : string, fallback : number) : number  {
    if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
      return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
    }
    return fallback;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages : {[key:string]:number} | undefined  = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages : Array<number>  = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

Go

main function, Go

var ages map[string]int64 = make(map[string]int64);
ages["ada"] = int64(36);
ages["alan"] = int64(41);
var all_ages []int64= operatorsOf_static_values_2(ages);
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )

The complete file

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

type GoNullable struct {
  value interface{}
  has_value bool
}

func r_get_string_int64( a map[string]int64, key string ) *GoNullable  {
  res := new(GoNullable)
  v, ok := a[key]
  if ok {
    res.has_value = true
    res.value = v
    return res
  }
  res.has_value = false
  return res
}
func r_has_key_string_int64( a map[string]int64, key string ) bool {
  _, ok := a[key]
  return ok

}
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var ages map[string]int64 = make(map[string]int64);
  ages["ada"] = int64(36);
  ages["alan"] = int64(41);
  var all_ages []int64= operatorsOf_static_values_2(ages);
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
  fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_values_2(__self map[string]int64) []int64 {
  var res []int64 = make([]int64, 0);
  var list []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  for _, kk := range list {
    res = append(res,r_get_string_int64(__self, kk).value.(int64));
  }
  return res
}
func operatorsOf_static_mapc95length_2(__self map[string]int64) int64 {
  var list_1 []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  return int64(len(list_1))
}
func operatorsOf_static_getc95or_3(__self map[string]int64, key string, fallback int64) int64 {
  if  r_has_key_string_int64(__self, key) {
    return r_get_string_int64(__self, key).value.(int64)
  }
  return fallback
}

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)]
#![allow(unused_mut)]

// FxHash (rustc-hash style): these maps are keyed by short program
// strings; SipHash's DoS resistance cost ~14% of all instructions in
// map-heavy code. Swap back to std's default by deleting the alias.
#[derive(Default, Clone)]
struct FxHasher { hash: u64 }
impl std::hash::Hasher for FxHasher {
    #[inline]
    fn write(&mut self, bytes: &[u8]) {
        const SEED: u64 = 0x517cc1b727220a95;
        let mut b = bytes;
        while b.len() >= 8 {
            let v = u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
            self.hash = (self.hash.rotate_left(5) ^ v).wrapping_mul(SEED);
            b = &b[8..];
        }
        for &x in b {
            self.hash = (self.hash.rotate_left(5) ^ (x as u64)).wrapping_mul(SEED);
        }
    }
    #[inline]
    fn finish(&self) -> u64 { self.hash }
}
// Insertion-ordered map (mirrors the C++ rg_ordered_map): entries in a
// vector plus an open-addressed FxHash index. Lookups hash once; keys()
// iterates in INSERTION order, which is what JS key enumeration needs.
// Aliased over the HashMap name so declarations stay untouched.
#[derive(Clone)]
struct RgOrderedMap<K, V> {
    entries: Vec<(K, V)>,
    index: Vec<i32>,
}
impl<K, V> Default for RgOrderedMap<K, V> {
    fn default() -> Self { RgOrderedMap { entries: Vec::new(), index: Vec::new() } }
}
impl<K, V> IntoIterator for RgOrderedMap<K, V> {
    type Item = (K, V);
    type IntoIter = std::vec::IntoIter<(K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.into_iter() }
}
impl<'a, K, V> IntoIterator for &'a RgOrderedMap<K, V> {
    type Item = &'a (K, V);
    type IntoIter = std::slice::Iter<'a, (K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.iter() }
}
impl<K: std::hash::Hash + Eq, V> RgOrderedMap<K, V> {
    fn rg_hash<Q: std::hash::Hash + ?Sized>(k: &Q) -> u64 {
        let mut h = FxHasher::default();
        k.hash(&mut h);
        std::hash::Hasher::finish(&h)
    }
    fn slot<Q>(&self, k: &Q) -> i32 where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        if self.index.is_empty() { return -1; }
        let mask = self.index.len() - 1;
        let mut h = (Self::rg_hash(k) as usize) & mask;
        loop {
            let s = self.index[h];
            if s == -1 { return -1; }
            if self.entries[s as usize].0.borrow() == k { return s; }
            h = (h + 1) & mask;
        }
    }
    fn rehash(&mut self) {
        let mut cap = 8usize;
        while cap < (self.entries.len() + 1) * 2 { cap <<= 1; }
        self.index.clear();
        self.index.resize(cap, -1);
        for i in 0..self.entries.len() {
            let mut h = (Self::rg_hash(&self.entries[i].0) as usize) & (cap - 1);
            while self.index[h] != -1 { h = (h + 1) & (cap - 1); }
            self.index[h] = i as i32;
        }
    }
    fn insert(&mut self, k: K, v: V) -> Option<V> {
        let s = self.slot(&k);
        if s != -1 { return Some(std::mem::replace(&mut self.entries[s as usize].1, v)); }
        self.entries.push((k, v));
        if self.index.is_empty() || (self.entries.len() + 1) * 2 > self.index.len() {
            self.rehash();
        } else {
            let mask = self.index.len() - 1;
            let mut h = (Self::rg_hash(&self.entries[self.entries.len() - 1].0) as usize) & mask;
            while self.index[h] != -1 { h = (h + 1) & mask; }
            self.index[h] = (self.entries.len() - 1) as i32;
        }
        None
    }
    fn get<Q>(&self, k: &Q) -> Option<&V> where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        let s = self.slot(k);
        if s == -1 { None } else { Some(&self.entries[s as usize].1) }
    }
    fn contains_key<Q>(&self, k: &Q) -> bool where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        self.slot(k) != -1
    }
    fn keys(&self) -> impl Iterator<Item = &K> { self.entries.iter().map(|e| &e.0) }
    fn len(&self) -> usize { self.entries.len() }
    fn clear(&mut self) {
        self.entries.clear();
        for s in self.index.iter_mut() { *s = -1; }
    }
}
type HashMap<K, V> = RgOrderedMap<K, V>;

#[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 ages: HashMap<String,i64> = HashMap::default();
  ages.insert("ada".to_string(), 36);
  ages.insert("alan".to_string(), 41);
  let mut all_ages: Vec<i64> = operatorsOf::values_2(&ages);
  println!("count {}", all_ages.len() as i64);
  println!("keys {}", operatorsOf::mapc95length_2(&ages));
  println!("grace {}", operatorsOf::getc95or_3(&ages, "grace", 0));
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn values_2(__self: &HashMap<String,i64>) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let mut list: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    for kk in list.iter().cloned() {
      res.push(__self.get(&kk).cloned().unwrap());
    }
    res.clone()
  }
  pub fn mapc95length_2(__self: &HashMap<String,i64>) -> i64 {
    let mut list_1: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    list_1.len() as i64
  }
  pub fn getc95or_3(__self: &HashMap<String,i64>, key: &str, fallback: i64) -> i64 {
    if  __self.contains_key(key) {
      return __self.get(key).cloned().unwrap();
    }
    fallback
  }
}

Python

main function, Python

ages = {}
ages["ada"] = 36;
ages["alan"] = 41;
all_ages = operatorsOf.values_2(ages)
print("count " + str(len(all_ages)))
print("keys " + str(operatorsOf.mapc95length_2(ages)))
print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))

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():
  ages = {}
  ages["ada"] = 36;
  ages["alan"] = 41;
  all_ages = operatorsOf.values_2(ages)
  print("count " + str(len(all_ages)))
  print("keys " + str(operatorsOf.mapc95length_2(ages)))
  print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def values_2(__self: dict[str, int]) -> list[int]:
    res = []
    _list = list(__self.keys())
    for kk in _list:
      res.append(__self.get(kk))
    return res;
  @staticmethod
  def mapc95length_2(__self: dict[str, int]) -> int:
    list_1 = list(__self.keys())
    return len(list_1);
  @staticmethod
  def getc95or_3(__self: dict[str, int], key: str, fallback: int) -> int:
    if key in __self:
      return __self.get(key);
    return fallback;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
HashMap<String,Integer> ages = new HashMap<String,Integer>();
ages.put("ada", 36);
ages.put("alan", 41);
final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
System.out.println(String.valueOf( "count " + all_ages.size() ) );
System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    HashMap<String,Integer> ages = new HashMap<String,Integer>();
    ages.put("ada", 36);
    ages.put("alan", 41);
    final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
    System.out.println(String.valueOf( "count " + all_ages.size() ) );
    System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
    System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );
  }
}


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


import java.util.*;

public class operatorsOf {

  public static ArrayList<Integer> values_2( final HashMap<String,Integer> __self ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final ArrayList<String> list = new ArrayList<>(__self.keySet());
    for ( String kk : list) {
      res.add(__self.get(kk));
    }
    return res;
  }

  public static Integer mapc95length_2( final HashMap<String,Integer> __self ) {
    final ArrayList<String> list_1 = new ArrayList<>(__self.keySet());
    return list_1.size();
  }

  public static Integer getc95or_3( final HashMap<String,Integer> __self , final String key , final Integer fallback ) {
    if ( __self.containsKey(key) ) {
      return __self.get(key);
    }
    return fallback;
  }
}

Kotlin

main function, Kotlin

__g_args = args
var ages : MutableMap<String,Int>  = hashMapOf();
ages.set("ada", 36)
ages.set("alan", 41)
val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
println( "count " + (all_ages.size).toString() )
println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var ages : MutableMap<String,Int>  = hashMapOf();
  ages.set("ada", 36)
  ages.set("alan", 41)
  val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
  println( "count " + (all_ages.size).toString() )
  println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
  println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )
}

class operatorsOf
 {
  companion object {

    fun  values_2( __self : MutableMap<String,Int>) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val list : MutableList<String>  = ArrayList(__self.keys);
      for ( kk in list ) {
        res.add(__self[kk]!!);
      }
      return res;
    }

    fun  mapc95length_2( __self : MutableMap<String,Int>) : Int {
      val list_1 : MutableList<String>  = ArrayList(__self.keys);
      return list_1.size;
    }

    fun  getc95or_3( __self : MutableMap<String,Int>, key : String, fallback : Int) : Int {
      if ( __self.containsKey(key) ) {
        return __self[key]!!;
      }
      return fallback;
    }
  }
}

Dart

main function, Dart

__g_args = args;
Map<String, int> ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
print( "count " + (all_ages.length).toString() );
print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  Map<String, int> ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  List<int> all_ages = operatorsOf.values_2(ages);
  print( "count " + (all_ages.length).toString() );
  print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
  print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );
}

class operatorsOf {

  static List<int> values_2(Map<String, int> __self) {
    List<int> res = [];
    List<String> list = __self.keys.toList();
    for ( final kk in list) {
      res.add(__self[kk]!);
    }
    return res;
  }

  static int mapc95length_2(Map<String, int> __self) {
    List<String> list_1 = __self.keys.toList();
    return list_1.length;
  }

  static int getc95or_3(Map<String, int> __self, String key, int fallback) {
    if ( __self.containsKey(key) ) {
      return __self[key]!;
    }
    return fallback;
  }
}

Swift

main function, Swift

var ages : [String:Int] = [String:Int]()
ages["ada"] = 36;
ages["alan"] = 41;
let all_ages : [Int] = operatorsOf.values_2(__self : ages)
print("count " + String(all_ages.count))
print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func values_2(__self : [String:Int]) -> [Int] {
    var res : [Int] = [Int]()
    let list : [String] = Array(__self.keys)
    for kk in list {
      res.append(__self[kk]!)
    }
    return res
  }
  class func mapc95length_2(__self : [String:Int]) -> Int {
    let list_1 : [String] = Array(__self.keys)
    return list_1.count
  }
  class func getc95or_3(__self : [String:Int], key : String, fallback : Int) -> Int {
    if ( __self[key] != nil ) {
      return __self[key]!
    }
    return fallback
  }
}
// Main entry point
func __main__swift() {
  var ages : [String:Int] = [String:Int]()
  ages["ada"] = 36;
  ages["alan"] = 41;
  let all_ages : [Int] = operatorsOf.values_2(__self : ages)
  print("count " + String(all_ages.count))
  print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
  print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))
}
__main__swift()

C#

main function, C#

Dictionary<String,int> ages = new Dictionary<String,int>();
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
Console.WriteLine("count " + all_ages.Count);
Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    Dictionary<String,int> ages = new Dictionary<String,int>();
    ages["ada"] = 36;
    ages["alan"] = 41;
    List<int> all_ages = operatorsOf.values_2(ages);
    Console.WriteLine("count " + all_ages.Count);
    Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
    Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
  }
}
class operatorsOf  {
  public static List<int> values_2( Dictionary<String,int> __self ) {
    List<int> res = new List<int>();
    List<String> list = new List<String>(__self.Keys);
    foreach ( String kk in list) {
      res.Add(((__self.ContainsKey(kk) ? (int?)__self[kk] : null)).Value);
    }
    return res;
  }
  public static int mapc95length_2( Dictionary<String,int> __self ) {
    List<String> list_1 = new List<String>(__self.Keys);
    return list_1.Count;
  }
  public static int getc95or_3( Dictionary<String,int> __self , String key , int fallback ) {
    if ( __self.ContainsKey(key) ) {
      return ((__self.ContainsKey(key) ? (int?)__self[key] : null)).Value;
    }
    return fallback;
  }
}

C++

main function, C++

rg_ordered_map<std::string,int> ages;
ages["ada"] = 36;
ages["alan"] = 41;
std::vector<int> all_ages = operatorsOf::values_2(ages);
std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
return 0;

The complete file

#include  <memory>
#include  <string_view>
#include  <vector>
#include  <cstring>
#include  <stdexcept>
#include  <map>
#include  <iostream>
#include  <string>

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


template< typename M >
std::vector<std::string> r_get_keys_of_map( const M & orig_map )  {
    std::vector<std::string> res;
    for(auto it = orig_map.begin(); it != orig_map.end(); ++it) {
        res.push_back(it->first);
    }
    return res;
}

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;
    }
};


template<typename M, typename K>
r_optional_primitive<int> cpp_get_map_int_value( const M & m , const K & key) {
r_optional_primitive<int> result;
result.has_value = false;
auto it = m.find(key);
if (it != m.end()) {
result.value = it->second;
result.has_value = true;
}
return result;
};

// String hashing for the map below. std::hash<std::string> is
// _Hash_bytes, an out-of-line MurmurHash in libstdc++ that costs a call
// and a per-byte mix; profiling the interpreter put it at ~10% of all
// instructions, since every scope lookup and every property read hashes
// a name. This is FxHash -- the one rustc uses for its own identifier
// maps -- which consumes 8 bytes per multiply-rotate and inlines.
//
// The string and string_view paths MUST agree, because the const char*
// overloads probe the same index; they share this one function, so they
// agree by construction rather than by the standard's promise about
// hash<string> and hash<string_view>.
static inline size_t rg_hash_bytes(const char* p, size_t n) {
    const size_t K = (size_t)0x517cc1b727220a95ULL;
    size_t h = n;
    size_t i = 0;
    while (n - i >= sizeof(size_t)) {
        size_t w; std::memcpy(&w, p + i, sizeof(size_t));
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ w; h *= K;
        i += sizeof(size_t);
    }
    while (i < n) {
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ (size_t)(unsigned char)p[i]; h *= K;
        i++;
    }
    return h;
}
// Any other key type keeps the standard hash; only strings are hot.
template<typename K> struct rg_key_hash {
    size_t operator()(const K& k) const { return std::hash<K>{}(k); }
};
template<> struct rg_key_hash<std::string> {
    size_t operator()(const std::string& s) const { return rg_hash_bytes(s.data(), s.size()); }
};
// Insertion-ordered map: vector storage + open-addressed hash index.
// Replaces std::map (sorted, O(log n) with a string compare per level):
// lookups hash once, and iteration follows INSERTION order, which is
// what JavaScript object key enumeration semantics need.
template<typename K, typename V>
class rg_ordered_map {
public:
    typedef K key_type;
    typedef V mapped_type;
    std::vector<std::pair<K, V>> entries;
    std::vector<int32_t> index_;
    typedef typename std::vector<std::pair<K, V>>::iterator iterator;
    typedef typename std::vector<std::pair<K, V>>::const_iterator const_iterator;
    iterator begin() { return entries.begin(); }
    iterator end() { return entries.end(); }
    const_iterator begin() const { return entries.begin(); }
    const_iterator end() const { return entries.end(); }
    size_t size() const { return entries.size(); }
    void clear() { entries.clear(); index_.clear(); }
    void rehash_() {
        size_t cap = 8;
        while (cap < (entries.size() + 1) * 2) { cap <<= 1; }
        index_.assign(cap, -1);
        for (size_t i = 0; i < entries.size(); i++) {
            size_t h = rg_key_hash<K>{}(entries[i].first) & (cap - 1);
            while (index_[h] != -1) { h = (h + 1) & (cap - 1); }
            index_[h] = (int32_t)i;
        }
    }
    int32_t slot_(const K& k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_key_hash<K>{}(k) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first == k) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const K& k) const { return slot_(k) == -1 ? 0 : 1; }
    iterator find(const K& k) {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const K& k) const {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const K& k) {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const K& k) const {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    // const char* overloads: a literal key probes WITHOUT constructing a
    // std::string temporary. C++17 guarantees hash<string> and
    // hash<string_view> agree on equal character sequences. Instantiated
    // lazily, so non-string-keyed maps never touch them.
    int32_t slot_sv_(std::string_view k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_hash_bytes(k.data(), k.size()) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first.compare(k) == 0) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const char* k) const { return slot_sv_(k) == -1 ? 0 : 1; }
    iterator find(const char* k) {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const char* k) const {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const char* k) {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const char* k) const {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    V& operator[](const char* k) {
        int32_t s = slot_sv_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        return (*this)[K(k)];
    }
    V& operator[](const K& k) {
        int32_t s = slot_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        entries.push_back(std::make_pair(k, V()));
        if (index_.empty() || (entries.size() + 1) * 2 > index_.size()) {
            rehash_();
        } else {
            size_t mask = index_.size() - 1;
            size_t h = rg_key_hash<K>{}(k) & mask;
            while (index_[h] != -1) { h = (h + 1) & mask; }
            index_[h] = (int32_t)(entries.size() - 1);
        }
        return entries.back().second;
    }
};

// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static std::vector<int> values_2( const rg_ordered_map<std::string,int>& __self );
    static int mapc95length_2( const rg_ordered_map<std::string,int>& __self );
    static int getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  rg_ordered_map<std::string,int> ages;
  ages["ada"] = 36;
  ages["alan"] = 41;
  std::vector<int> all_ages = operatorsOf::values_2(ages);
  std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
  std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
  std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
std::vector<int>  operatorsOf::values_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<int> res;
  std::vector<std::string> list = r_get_keys_of_map(__self);
  for ( const std::string& kk : list ) {
    res.push_back( /*unwrap int*/cpp_get_map_int_value(__self, kk).value  );
  }
  return res;
}
int  operatorsOf::mapc95length_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<std::string> list_1 = r_get_keys_of_map(__self);
  return (int)(list_1.size());
}
int  operatorsOf::getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback ) {
  if ( __self.count(key) > 0 ) {
    return /*unwrap int*/cpp_get_map_int_value(__self, key).value;
  }
  return fallback;
}

PHP

main function, PHP

$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

Scala

main function, Scala

var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
ages.put("ada", 36)
ages.put("alan", 41)
val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
println( "count " + all_ages.length )
println( "keys " + operatorsOf.mapc95length_2(ages) )
println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  values_2( __self : collection.mutable.HashMap[String, Int]) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val list : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    for( kk <- list ) {
      res.append(__self.get(kk).get)
    }
    return res
  }
  def  mapc95length_2( __self : collection.mutable.HashMap[String, Int]) : Int = {
    val list_1 : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    return list_1.length
  }
  def  getc95or_3( __self : collection.mutable.HashMap[String, Int], key : String, fallback : Int) : Int = {
    if ( __self.contains(key) ) {
      return __self.get(key).get
    }
    return fallback
  }
}

// application main function for Main
object AppMain extends App {
  var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
  ages.put("ada", 36)
  ages.put("alan", 41)
  val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
  println( "count " + all_ages.length )
  println( "keys " + operatorsOf.mapc95length_2(ages) )
  println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )
}

The Ranger source of the method

fn map_length:int () @doc('Number of keys in the map') {
    def list (keys self)
    return (array_length list)
}

Definition: lib/stdlib.rgr, line 687

values

receiver.values() → [T]

All values of the map

The compiler writes this method for every target.

Values, size and default value of a map

docs/examples/lib/stdlib/map-helpers.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def ages:[string:int]
        set ages "ada" 36
        set ages "alan" 41
        def all_ages (ages.values())
        print ("count " + (array_length all_ages))
        print ("keys " + (ages.map_length()))
        print ("grace " + (ages.get_or("grace" 0)))
    }
}

JavaScript

main function, JavaScript

let ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.values_2 = function(__self) {
  let res = [];
  const list = Object.keys(__self);
  for ( const kk of list) {
    res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
  }
  return res;
};
operatorsOf.mapc95length_2 = function(__self) {
  const list_1 = Object.keys(__self);
  return list_1.length;
};
operatorsOf.getc95or_3 = function(__self, key, fallback) {
  if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
    return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
  }
  return fallback;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

TypeScript

main function, TypeScript

let ages : {[key:string]:number} | undefined  = {};
ages["ada"] = 36;
ages["alan"] = 41;
const all_ages : Array<number>  = operatorsOf.values_2(ages);
console.log("count " + all_ages.length);
console.log("keys " + operatorsOf.mapc95length_2(ages));
console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static values_2 (__self : {[key:string]:number}) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const list : Array<string>  = Object.keys(__self);
    for ( const kk of list) {
      res.push(( Object.prototype.hasOwnProperty.call(__self, kk) ? __self[kk] : undefined ));
    }
    return res;
  };
  static mapc95length_2 (__self : {[key:string]:number}) : number  {
    const list_1 : Array<string>  = Object.keys(__self);
    return list_1.length;
  };
  static getc95or_3 (__self : {[key:string]:number}, key : string, fallback : number) : number  {
    if ( ( typeof(__self[key] ) != "undefined" && Object.prototype.hasOwnProperty.call(__self, key) ) ) {
      return ( Object.prototype.hasOwnProperty.call(__self, key) ? __self[key] : undefined );
    }
    return fallback;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  let ages : {[key:string]:number} | undefined  = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  const all_ages : Array<number>  = operatorsOf.values_2(ages);
  console.log("count " + all_ages.length);
  console.log("keys " + operatorsOf.mapc95length_2(ages));
  console.log("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
}
__js_main();

Go

main function, Go

var ages map[string]int64 = make(map[string]int64);
ages["ada"] = int64(36);
ages["alan"] = int64(41);
var all_ages []int64= operatorsOf_static_values_2(ages);
fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )

The complete file

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

type GoNullable struct {
  value interface{}
  has_value bool
}

func r_get_string_int64( a map[string]int64, key string ) *GoNullable  {
  res := new(GoNullable)
  v, ok := a[key]
  if ok {
    res.has_value = true
    res.value = v
    return res
  }
  res.has_value = false
  return res
}
func r_has_key_string_int64( a map[string]int64, key string ) bool {
  _, ok := a[key]
  return ok

}
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var ages map[string]int64 = make(map[string]int64);
  ages["ada"] = int64(36);
  ages["alan"] = int64(41);
  var all_ages []int64= operatorsOf_static_values_2(ages);
  fmt.Println( strings.Join([]string{ "count ",strconv.FormatInt(int64(len(all_ages)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "keys ",strconv.FormatInt(operatorsOf_static_mapc95length_2(ages), 10) }, "") )
  fmt.Println( strings.Join([]string{ "grace ",strconv.FormatInt(operatorsOf_static_getc95or_3(ages, "grace", int64(0)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_values_2(__self map[string]int64) []int64 {
  var res []int64 = make([]int64, 0);
  var list []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  for _, kk := range list {
    res = append(res,r_get_string_int64(__self, kk).value.(int64));
  }
  return res
}
func operatorsOf_static_mapc95length_2(__self map[string]int64) int64 {
  var list_1 []string= (func() []string {
    keys := reflect.ValueOf(__self).MapKeys()
    strkeys := make([]string, len(keys))
    for i := 0; i < len(keys); i++ {
      strkeys[i] = keys[i].String()
    }
    return strkeys
  })();
  return int64(len(list_1))
}
func operatorsOf_static_getc95or_3(__self map[string]int64, key string, fallback int64) int64 {
  if  r_has_key_string_int64(__self, key) {
    return r_get_string_int64(__self, key).value.(int64)
  }
  return fallback
}

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)]
#![allow(unused_mut)]

// FxHash (rustc-hash style): these maps are keyed by short program
// strings; SipHash's DoS resistance cost ~14% of all instructions in
// map-heavy code. Swap back to std's default by deleting the alias.
#[derive(Default, Clone)]
struct FxHasher { hash: u64 }
impl std::hash::Hasher for FxHasher {
    #[inline]
    fn write(&mut self, bytes: &[u8]) {
        const SEED: u64 = 0x517cc1b727220a95;
        let mut b = bytes;
        while b.len() >= 8 {
            let v = u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
            self.hash = (self.hash.rotate_left(5) ^ v).wrapping_mul(SEED);
            b = &b[8..];
        }
        for &x in b {
            self.hash = (self.hash.rotate_left(5) ^ (x as u64)).wrapping_mul(SEED);
        }
    }
    #[inline]
    fn finish(&self) -> u64 { self.hash }
}
// Insertion-ordered map (mirrors the C++ rg_ordered_map): entries in a
// vector plus an open-addressed FxHash index. Lookups hash once; keys()
// iterates in INSERTION order, which is what JS key enumeration needs.
// Aliased over the HashMap name so declarations stay untouched.
#[derive(Clone)]
struct RgOrderedMap<K, V> {
    entries: Vec<(K, V)>,
    index: Vec<i32>,
}
impl<K, V> Default for RgOrderedMap<K, V> {
    fn default() -> Self { RgOrderedMap { entries: Vec::new(), index: Vec::new() } }
}
impl<K, V> IntoIterator for RgOrderedMap<K, V> {
    type Item = (K, V);
    type IntoIter = std::vec::IntoIter<(K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.into_iter() }
}
impl<'a, K, V> IntoIterator for &'a RgOrderedMap<K, V> {
    type Item = &'a (K, V);
    type IntoIter = std::slice::Iter<'a, (K, V)>;
    fn into_iter(self) -> Self::IntoIter { self.entries.iter() }
}
impl<K: std::hash::Hash + Eq, V> RgOrderedMap<K, V> {
    fn rg_hash<Q: std::hash::Hash + ?Sized>(k: &Q) -> u64 {
        let mut h = FxHasher::default();
        k.hash(&mut h);
        std::hash::Hasher::finish(&h)
    }
    fn slot<Q>(&self, k: &Q) -> i32 where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        if self.index.is_empty() { return -1; }
        let mask = self.index.len() - 1;
        let mut h = (Self::rg_hash(k) as usize) & mask;
        loop {
            let s = self.index[h];
            if s == -1 { return -1; }
            if self.entries[s as usize].0.borrow() == k { return s; }
            h = (h + 1) & mask;
        }
    }
    fn rehash(&mut self) {
        let mut cap = 8usize;
        while cap < (self.entries.len() + 1) * 2 { cap <<= 1; }
        self.index.clear();
        self.index.resize(cap, -1);
        for i in 0..self.entries.len() {
            let mut h = (Self::rg_hash(&self.entries[i].0) as usize) & (cap - 1);
            while self.index[h] != -1 { h = (h + 1) & (cap - 1); }
            self.index[h] = i as i32;
        }
    }
    fn insert(&mut self, k: K, v: V) -> Option<V> {
        let s = self.slot(&k);
        if s != -1 { return Some(std::mem::replace(&mut self.entries[s as usize].1, v)); }
        self.entries.push((k, v));
        if self.index.is_empty() || (self.entries.len() + 1) * 2 > self.index.len() {
            self.rehash();
        } else {
            let mask = self.index.len() - 1;
            let mut h = (Self::rg_hash(&self.entries[self.entries.len() - 1].0) as usize) & mask;
            while self.index[h] != -1 { h = (h + 1) & mask; }
            self.index[h] = (self.entries.len() - 1) as i32;
        }
        None
    }
    fn get<Q>(&self, k: &Q) -> Option<&V> where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        let s = self.slot(k);
        if s == -1 { None } else { Some(&self.entries[s as usize].1) }
    }
    fn contains_key<Q>(&self, k: &Q) -> bool where K: std::borrow::Borrow<Q>, Q: std::hash::Hash + Eq + ?Sized {
        self.slot(k) != -1
    }
    fn keys(&self) -> impl Iterator<Item = &K> { self.entries.iter().map(|e| &e.0) }
    fn len(&self) -> usize { self.entries.len() }
    fn clear(&mut self) {
        self.entries.clear();
        for s in self.index.iter_mut() { *s = -1; }
    }
}
type HashMap<K, V> = RgOrderedMap<K, V>;

#[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 ages: HashMap<String,i64> = HashMap::default();
  ages.insert("ada".to_string(), 36);
  ages.insert("alan".to_string(), 41);
  let mut all_ages: Vec<i64> = operatorsOf::values_2(&ages);
  println!("count {}", all_ages.len() as i64);
  println!("keys {}", operatorsOf::mapc95length_2(&ages));
  println!("grace {}", operatorsOf::getc95or_3(&ages, "grace", 0));
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn values_2(__self: &HashMap<String,i64>) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let mut list: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    for kk in list.iter().cloned() {
      res.push(__self.get(&kk).cloned().unwrap());
    }
    res.clone()
  }
  pub fn mapc95length_2(__self: &HashMap<String,i64>) -> i64 {
    let mut list_1: Vec<String> = __self.keys().cloned().collect::<Vec<String>>();
    list_1.len() as i64
  }
  pub fn getc95or_3(__self: &HashMap<String,i64>, key: &str, fallback: i64) -> i64 {
    if  __self.contains_key(key) {
      return __self.get(key).cloned().unwrap();
    }
    fallback
  }
}

Python

main function, Python

ages = {}
ages["ada"] = 36;
ages["alan"] = 41;
all_ages = operatorsOf.values_2(ages)
print("count " + str(len(all_ages)))
print("keys " + str(operatorsOf.mapc95length_2(ages)))
print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))

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():
  ages = {}
  ages["ada"] = 36;
  ages["alan"] = 41;
  all_ages = operatorsOf.values_2(ages)
  print("count " + str(len(all_ages)))
  print("keys " + str(operatorsOf.mapc95length_2(ages)))
  print("grace " + str(operatorsOf.getc95or_3(ages, "grace", 0)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def values_2(__self: dict[str, int]) -> list[int]:
    res = []
    _list = list(__self.keys())
    for kk in _list:
      res.append(__self.get(kk))
    return res;
  @staticmethod
  def mapc95length_2(__self: dict[str, int]) -> int:
    list_1 = list(__self.keys())
    return len(list_1);
  @staticmethod
  def getc95or_3(__self: dict[str, int], key: str, fallback: int) -> int:
    if key in __self:
      return __self.get(key);
    return fallback;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
HashMap<String,Integer> ages = new HashMap<String,Integer>();
ages.put("ada", 36);
ages.put("alan", 41);
final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
System.out.println(String.valueOf( "count " + all_ages.size() ) );
System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    HashMap<String,Integer> ages = new HashMap<String,Integer>();
    ages.put("ada", 36);
    ages.put("alan", 41);
    final ArrayList<Integer> all_ages = operatorsOf.values_2(ages);
    System.out.println(String.valueOf( "count " + all_ages.size() ) );
    System.out.println(String.valueOf( "keys " + operatorsOf.mapc95length_2(ages) ) );
    System.out.println(String.valueOf( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) ) );
  }
}


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


import java.util.*;

public class operatorsOf {

  public static ArrayList<Integer> values_2( final HashMap<String,Integer> __self ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final ArrayList<String> list = new ArrayList<>(__self.keySet());
    for ( String kk : list) {
      res.add(__self.get(kk));
    }
    return res;
  }

  public static Integer mapc95length_2( final HashMap<String,Integer> __self ) {
    final ArrayList<String> list_1 = new ArrayList<>(__self.keySet());
    return list_1.size();
  }

  public static Integer getc95or_3( final HashMap<String,Integer> __self , final String key , final Integer fallback ) {
    if ( __self.containsKey(key) ) {
      return __self.get(key);
    }
    return fallback;
  }
}

Kotlin

main function, Kotlin

__g_args = args
var ages : MutableMap<String,Int>  = hashMapOf();
ages.set("ada", 36)
ages.set("alan", 41)
val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
println( "count " + (all_ages.size).toString() )
println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  var ages : MutableMap<String,Int>  = hashMapOf();
  ages.set("ada", 36)
  ages.set("alan", 41)
  val all_ages : MutableList<Int>  = operatorsOf.values_2(ages);
  println( "count " + (all_ages.size).toString() )
  println( "keys " + (operatorsOf.mapc95length_2(ages)).toString() )
  println( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() )
}

class operatorsOf
 {
  companion object {

    fun  values_2( __self : MutableMap<String,Int>) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val list : MutableList<String>  = ArrayList(__self.keys);
      for ( kk in list ) {
        res.add(__self[kk]!!);
      }
      return res;
    }

    fun  mapc95length_2( __self : MutableMap<String,Int>) : Int {
      val list_1 : MutableList<String>  = ArrayList(__self.keys);
      return list_1.size;
    }

    fun  getc95or_3( __self : MutableMap<String,Int>, key : String, fallback : Int) : Int {
      if ( __self.containsKey(key) ) {
        return __self[key]!!;
      }
      return fallback;
    }
  }
}

Dart

main function, Dart

__g_args = args;
Map<String, int> ages = {};
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
print( "count " + (all_ages.length).toString() );
print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  Map<String, int> ages = {};
  ages["ada"] = 36;
  ages["alan"] = 41;
  List<int> all_ages = operatorsOf.values_2(ages);
  print( "count " + (all_ages.length).toString() );
  print( "keys " + (operatorsOf.mapc95length_2(ages)).toString() );
  print( "grace " + (operatorsOf.getc95or_3(ages, "grace", 0)).toString() );
}

class operatorsOf {

  static List<int> values_2(Map<String, int> __self) {
    List<int> res = [];
    List<String> list = __self.keys.toList();
    for ( final kk in list) {
      res.add(__self[kk]!);
    }
    return res;
  }

  static int mapc95length_2(Map<String, int> __self) {
    List<String> list_1 = __self.keys.toList();
    return list_1.length;
  }

  static int getc95or_3(Map<String, int> __self, String key, int fallback) {
    if ( __self.containsKey(key) ) {
      return __self[key]!;
    }
    return fallback;
  }
}

Swift

main function, Swift

var ages : [String:Int] = [String:Int]()
ages["ada"] = 36;
ages["alan"] = 41;
let all_ages : [Int] = operatorsOf.values_2(__self : ages)
print("count " + String(all_ages.count))
print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func values_2(__self : [String:Int]) -> [Int] {
    var res : [Int] = [Int]()
    let list : [String] = Array(__self.keys)
    for kk in list {
      res.append(__self[kk]!)
    }
    return res
  }
  class func mapc95length_2(__self : [String:Int]) -> Int {
    let list_1 : [String] = Array(__self.keys)
    return list_1.count
  }
  class func getc95or_3(__self : [String:Int], key : String, fallback : Int) -> Int {
    if ( __self[key] != nil ) {
      return __self[key]!
    }
    return fallback
  }
}
// Main entry point
func __main__swift() {
  var ages : [String:Int] = [String:Int]()
  ages["ada"] = 36;
  ages["alan"] = 41;
  let all_ages : [Int] = operatorsOf.values_2(__self : ages)
  print("count " + String(all_ages.count))
  print("keys " + String(operatorsOf.mapc95length_2(__self : ages)))
  print("grace " + String(operatorsOf.getc95or_3(__self : ages, key : "grace", fallback : 0)))
}
__main__swift()

C#

main function, C#

Dictionary<String,int> ages = new Dictionary<String,int>();
ages["ada"] = 36;
ages["alan"] = 41;
List<int> all_ages = operatorsOf.values_2(ages);
Console.WriteLine("count " + all_ages.Count);
Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));

The complete file

using System;
using System.Collections;
using System.Collections.Generic;
class Main  {
  static void Main( string [] args ) {
    Dictionary<String,int> ages = new Dictionary<String,int>();
    ages["ada"] = 36;
    ages["alan"] = 41;
    List<int> all_ages = operatorsOf.values_2(ages);
    Console.WriteLine("count " + all_ages.Count);
    Console.WriteLine("keys " + operatorsOf.mapc95length_2(ages));
    Console.WriteLine("grace " + operatorsOf.getc95or_3(ages, "grace", 0));
  }
}
class operatorsOf  {
  public static List<int> values_2( Dictionary<String,int> __self ) {
    List<int> res = new List<int>();
    List<String> list = new List<String>(__self.Keys);
    foreach ( String kk in list) {
      res.Add(((__self.ContainsKey(kk) ? (int?)__self[kk] : null)).Value);
    }
    return res;
  }
  public static int mapc95length_2( Dictionary<String,int> __self ) {
    List<String> list_1 = new List<String>(__self.Keys);
    return list_1.Count;
  }
  public static int getc95or_3( Dictionary<String,int> __self , String key , int fallback ) {
    if ( __self.ContainsKey(key) ) {
      return ((__self.ContainsKey(key) ? (int?)__self[key] : null)).Value;
    }
    return fallback;
  }
}

C++

main function, C++

rg_ordered_map<std::string,int> ages;
ages["ada"] = 36;
ages["alan"] = 41;
std::vector<int> all_ages = operatorsOf::values_2(ages);
std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
return 0;

The complete file

#include  <memory>
#include  <string_view>
#include  <vector>
#include  <cstring>
#include  <stdexcept>
#include  <map>
#include  <iostream>
#include  <string>

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


template< typename M >
std::vector<std::string> r_get_keys_of_map( const M & orig_map )  {
    std::vector<std::string> res;
    for(auto it = orig_map.begin(); it != orig_map.end(); ++it) {
        res.push_back(it->first);
    }
    return res;
}

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;
    }
};


template<typename M, typename K>
r_optional_primitive<int> cpp_get_map_int_value( const M & m , const K & key) {
r_optional_primitive<int> result;
result.has_value = false;
auto it = m.find(key);
if (it != m.end()) {
result.value = it->second;
result.has_value = true;
}
return result;
};

// String hashing for the map below. std::hash<std::string> is
// _Hash_bytes, an out-of-line MurmurHash in libstdc++ that costs a call
// and a per-byte mix; profiling the interpreter put it at ~10% of all
// instructions, since every scope lookup and every property read hashes
// a name. This is FxHash -- the one rustc uses for its own identifier
// maps -- which consumes 8 bytes per multiply-rotate and inlines.
//
// The string and string_view paths MUST agree, because the const char*
// overloads probe the same index; they share this one function, so they
// agree by construction rather than by the standard's promise about
// hash<string> and hash<string_view>.
static inline size_t rg_hash_bytes(const char* p, size_t n) {
    const size_t K = (size_t)0x517cc1b727220a95ULL;
    size_t h = n;
    size_t i = 0;
    while (n - i >= sizeof(size_t)) {
        size_t w; std::memcpy(&w, p + i, sizeof(size_t));
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ w; h *= K;
        i += sizeof(size_t);
    }
    while (i < n) {
        h = ((h << 5) | (h >> (8 * sizeof(size_t) - 5))) ^ (size_t)(unsigned char)p[i]; h *= K;
        i++;
    }
    return h;
}
// Any other key type keeps the standard hash; only strings are hot.
template<typename K> struct rg_key_hash {
    size_t operator()(const K& k) const { return std::hash<K>{}(k); }
};
template<> struct rg_key_hash<std::string> {
    size_t operator()(const std::string& s) const { return rg_hash_bytes(s.data(), s.size()); }
};
// Insertion-ordered map: vector storage + open-addressed hash index.
// Replaces std::map (sorted, O(log n) with a string compare per level):
// lookups hash once, and iteration follows INSERTION order, which is
// what JavaScript object key enumeration semantics need.
template<typename K, typename V>
class rg_ordered_map {
public:
    typedef K key_type;
    typedef V mapped_type;
    std::vector<std::pair<K, V>> entries;
    std::vector<int32_t> index_;
    typedef typename std::vector<std::pair<K, V>>::iterator iterator;
    typedef typename std::vector<std::pair<K, V>>::const_iterator const_iterator;
    iterator begin() { return entries.begin(); }
    iterator end() { return entries.end(); }
    const_iterator begin() const { return entries.begin(); }
    const_iterator end() const { return entries.end(); }
    size_t size() const { return entries.size(); }
    void clear() { entries.clear(); index_.clear(); }
    void rehash_() {
        size_t cap = 8;
        while (cap < (entries.size() + 1) * 2) { cap <<= 1; }
        index_.assign(cap, -1);
        for (size_t i = 0; i < entries.size(); i++) {
            size_t h = rg_key_hash<K>{}(entries[i].first) & (cap - 1);
            while (index_[h] != -1) { h = (h + 1) & (cap - 1); }
            index_[h] = (int32_t)i;
        }
    }
    int32_t slot_(const K& k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_key_hash<K>{}(k) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first == k) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const K& k) const { return slot_(k) == -1 ? 0 : 1; }
    iterator find(const K& k) {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const K& k) const {
        int32_t s = slot_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const K& k) {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const K& k) const {
        int32_t s = slot_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    // const char* overloads: a literal key probes WITHOUT constructing a
    // std::string temporary. C++17 guarantees hash<string> and
    // hash<string_view> agree on equal character sequences. Instantiated
    // lazily, so non-string-keyed maps never touch them.
    int32_t slot_sv_(std::string_view k) const {
        if (index_.empty()) { return -1; }
        size_t mask = index_.size() - 1;
        size_t h = rg_hash_bytes(k.data(), k.size()) & mask;
        while (true) {
            int32_t s = index_[h];
            if (s == -1) { return -1; }
            if (entries[(size_t)s].first.compare(k) == 0) { return s; }
            h = (h + 1) & mask;
        }
    }
    size_t count(const char* k) const { return slot_sv_(k) == -1 ? 0 : 1; }
    iterator find(const char* k) {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    const_iterator find(const char* k) const {
        int32_t s = slot_sv_(k);
        return s == -1 ? entries.end() : entries.begin() + s;
    }
    V& at(const char* k) {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    const V& at(const char* k) const {
        int32_t s = slot_sv_(k);
        if (s == -1) { throw std::out_of_range("rg_ordered_map::at"); }
        return entries[(size_t)s].second;
    }
    V& operator[](const char* k) {
        int32_t s = slot_sv_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        return (*this)[K(k)];
    }
    V& operator[](const K& k) {
        int32_t s = slot_(k);
        if (s != -1) { return entries[(size_t)s].second; }
        entries.push_back(std::make_pair(k, V()));
        if (index_.empty() || (entries.size() + 1) * 2 > index_.size()) {
            rehash_();
        } else {
            size_t mask = index_.size() - 1;
            size_t h = rg_key_hash<K>{}(k) & mask;
            while (index_[h] != -1) { h = (h + 1) & mask; }
            index_[h] = (int32_t)(entries.size() - 1);
        }
        return entries.back().second;
    }
};

// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static std::vector<int> values_2( const rg_ordered_map<std::string,int>& __self );
    static int mapc95length_2( const rg_ordered_map<std::string,int>& __self );
    static int getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  rg_ordered_map<std::string,int> ages;
  ages["ada"] = 36;
  ages["alan"] = 41;
  std::vector<int> all_ages = operatorsOf::values_2(ages);
  std::cout << std::string("count ") + std::to_string((int)(all_ages.size())) << std::endl;
  std::cout << std::string("keys ") + std::to_string(operatorsOf::mapc95length_2(ages)) << std::endl;
  std::cout << std::string("grace ") + std::to_string(operatorsOf::getc95or_3(ages, std::string("grace"), 0)) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
std::vector<int>  operatorsOf::values_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<int> res;
  std::vector<std::string> list = r_get_keys_of_map(__self);
  for ( const std::string& kk : list ) {
    res.push_back( /*unwrap int*/cpp_get_map_int_value(__self, kk).value  );
  }
  return res;
}
int  operatorsOf::mapc95length_2( const rg_ordered_map<std::string,int>& __self ) {
  std::vector<std::string> list_1 = r_get_keys_of_map(__self);
  return (int)(list_1.size());
}
int  operatorsOf::getc95or_3( const rg_ordered_map<std::string,int>& __self , const std::string& key , int fallback ) {
  if ( __self.count(key) > 0 ) {
    return /*unwrap int*/cpp_get_map_int_value(__self, key).value;
  }
  return fallback;
}

PHP

main function, PHP

$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$ages = array();
$ages["ada"] = 36;
$ages["alan"] = 41;
$all_ages = operatorsOf::values_2($ages);
echo( "count " . count($all_ages) . "\n");
echo( "keys " . operatorsOf::mapc95length_2($ages) . "\n");
echo( "grace " . operatorsOf::getc95or_3($ages, "grace", 0) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function values_2( $__self ) {
    $res = array();
    $list = array_keys($__self);
    foreach ( $list as $kk ) {
      array_push($res, $__self[$kk]);
    }
    return $res;
  }
  public static function mapc95length_2( $__self ) {
    $list_1 = array_keys($__self);
    return count($list_1);
  }
  public static function getc95or_3( $__self , $key , $fallback ) {
    if ( array_key_exists($key , $__self ) ) {
      return $__self[$key];
    }
    return $fallback;
  }
}

Scala

main function, Scala

var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
ages.put("ada", 36)
ages.put("alan", 41)
val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
println( "count " + all_ages.length )
println( "keys " + operatorsOf.mapc95length_2(ages) )
println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  values_2( __self : collection.mutable.HashMap[String, Int]) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val list : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    for( kk <- list ) {
      res.append(__self.get(kk).get)
    }
    return res
  }
  def  mapc95length_2( __self : collection.mutable.HashMap[String, Int]) : Int = {
    val list_1 : collection.mutable.ArrayBuffer[String] = __self.keys.to[collection.mutable.ArrayBuffer]
    return list_1.length
  }
  def  getc95or_3( __self : collection.mutable.HashMap[String, Int], key : String, fallback : Int) : Int = {
    if ( __self.contains(key) ) {
      return __self.get(key).get
    }
    return fallback
  }
}

// application main function for Main
object AppMain extends App {
  var ages : collection.mutable.HashMap[String, Int] = new collection.mutable.HashMap()
  ages.put("ada", 36)
  ages.put("alan", 41)
  val all_ages : collection.mutable.ArrayBuffer[Int] = operatorsOf.values_2(ages)
  println( "count " + all_ages.length )
  println( "keys " + operatorsOf.mapc95length_2(ages) )
  println( "grace " + operatorsOf.getc95or_3(ages, "grace", 0) )
}

The Ranger source of the method

fn values:[T] () @doc('All values of the map') {
    def res:[T]
    def list (keys self)
    for list kk:string i {
        push res (unwrap (get self kk))
    }
    return res
}

Definition: lib/stdlib.rgr, line 678

[T]

Method	Arguments	Gives	Targets
all	cb: (fn:boolean (item:T))	boolean	every target
any	cb: (fn:boolean (item:T))	boolean	every target
clone	—	[T]	every target
contains	cb: (fn:boolean (item:T))	boolean	every target
count	cb: (fn:boolean (item:T))	int	every target
filter	cb: (fn:boolean (item:T index:int))	[T]	every target
find	cb: (fn:boolean (item:T))	T	every target
forEach	cb: (fn:void (item:T index:int))	void	every target
groupBy	cb: (fn:string (item:T))	[T]	every target
has	el: T	boolean	every target
map	cb: (fn:S (item:T index:int)), to: [S]	[S]	every target
map	cb: (fn:T (item:T index:int))	[T]	every target
reduce	cb: (fn:K (left:K right:T index:int)), initialValue: K	K	every target
reduce	cb: (fn:T (left:T right:T index:int)), initialValue: T	T	every target
slice	start: int, end: int	[T]	every target

all

receiver.all(cb) → boolean

all(cb: (fn:boolean (item:T)))

True when `cb` holds for every item (true when empty)

The compiler writes this method for every target.

Test the items of an array and take a part of it

docs/examples/lib/stdlib/tests-and-slice.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def numbers:[int] ([] _:int (1 2 3 4 5))
        if (numbers.any({ return (item > 4) })) {
            print "one item is greater than four"
        }
        if (numbers.all({ return (item > 0) })) {
            print "every item is positive"
        }
        def part (numbers.slice(1 3))
        print ("part " + (array_length part))
    }
}

JavaScript

main function, JavaScript

const numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item) => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item) => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.any_2 = function(__self, cb) {
  for ( const it of __self) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
};
operatorsOf.all_2 = function(__self, cb) {
  for ( const it_1 of __self) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
};
operatorsOf.slice_3 = function(__self, start, end) {
  let res = [];
  const __len = __self.length;
  let from = start;
  let to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  let i_2 = from;
  while (i_2 < to) {
    res.push(__self[i_2]);
    i_2 = i_2 + 1;
  };
  return res;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item) => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item) => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

TypeScript

main function, TypeScript

const numbers : Array<number>  = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static any_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it of __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  };
  static all_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it_1 of __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  };
  static slice_3 (__self : Array<number>, start : number, end : number) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const __len : number  = __self.length;
    let from : number  = start;
    let to : number  = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    let i_2 : number  = from;
    while (i_2 < to) {
      res.push(__self[i_2]);
      i_2 = i_2 + 1;
    };
    return res;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers : Array<number>  = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

Go

main function, Go

var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
if  operatorsOf_static_any_2(numbers, func (item int64) bool {
  return item > int64(4)
}) {
  fmt.Println( "one item is greater than four" )
}
if  operatorsOf_static_all_2(numbers, func (item int64) bool {
  return item > int64(0)
}) {
  fmt.Println( "every item is positive" )
}
var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )

The complete file

package main
import (
  "fmt"
  "strings"
  "strconv"
)
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
  if  operatorsOf_static_any_2(numbers, func (item int64) bool {
    return item > int64(4)
  }) {
    fmt.Println( "one item is greater than four" )
  }
  if  operatorsOf_static_all_2(numbers, func (item int64) bool {
    return item > int64(0)
  }) {
    fmt.Println( "every item is positive" )
  }
  var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
  fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_any_2(__self []int64, cb func(int64) bool) bool {
  for _, it := range __self {
    if  cb(it) {
      return true
    }
  }
  return false
}
func operatorsOf_static_all_2(__self []int64, cb func(int64) bool) bool {
  for _, it_1 := range __self {
    if  cb(it_1) == false {
      return false
    }
  }
  return true
}
func operatorsOf_static_slice_3(__self []int64, start int64, end int64) []int64 {
  var res []int64 = make([]int64, 0);
  var __len int64= int64(len(__self));
  var from int64= start;
  var to int64= end;
  if  from < int64(0) {
    from = int64(0);
  }
  if  to > __len {
    to = __len;
  }
  var i_2 int64= from;
  for i_2 < to {
    res = append(res,__self[i_2]);
    i_2 = i_2 + int64(1);
  }
  return res
}

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)]
#![allow(unused_mut)]

#[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![1, 2, 3, 4, 5];
  if  operatorsOf::any_2(&numbers, &mut |mut item| {
    return item > 4;
  }) {
    println!("one item is greater than four");
  }
  if  operatorsOf::all_2(&numbers, &mut |mut item| {
    return item > 0;
  }) {
    println!("every item is positive");
  }
  let mut part: Vec<i64> = operatorsOf::slice_3(&numbers, 1, 3);
  println!("part {}", part.len() as i64);
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn any_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it in __self.iter().copied() {
      if  cb(it) {
        return true;
      }
    }
    false
  }
  pub fn all_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it_1 in __self.iter().copied() {
      if  !(cb(it_1)) {
        return false;
      }
    }
    true
  }
  pub fn slice_3(__self: &[i64], start: i64, end: i64) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let __len: i64 = __self.len() as i64;
    let mut from: i64 = start;
    let mut to: i64 = end;
    if  from < 0 {
      from = 0;
    }
    if  to > __len {
      to = __len;
    }
    let mut i_2: i64 = from;
    while i_2 < to {
      res.push(__self[(i_2) as usize]);
      i_2 += 1;
    };
    res.clone()
  }
}

Python

main function, Python

def __rg_lambda_1(item):
  return item > 4;
def __rg_lambda_2(item):
  return item > 0;
numbers = [1, 2, 3, 4, 5]
if operatorsOf.any_2(numbers, __rg_lambda_1):
  print("one item is greater than four")
if operatorsOf.all_2(numbers, __rg_lambda_2):
  print("every item is positive")
part = operatorsOf.slice_3(numbers, 1, 3)
print("part " + str(len(part)))

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():
  def __rg_lambda_1(item):
    return item > 4;
  def __rg_lambda_2(item):
    return item > 0;
  numbers = [1, 2, 3, 4, 5]
  if operatorsOf.any_2(numbers, __rg_lambda_1):
    print("one item is greater than four")
  if operatorsOf.all_2(numbers, __rg_lambda_2):
    print("every item is positive")
  part = operatorsOf.slice_3(numbers, 1, 3)
  print("part " + str(len(part)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def any_2(__self: list[int], cb) -> bool:
    for it in __self:
      if cb(it):
        return True;
    return False;
  @staticmethod
  def all_2(__self: list[int], cb) -> bool:
    for it_1 in __self:
      if cb(it_1) == False:
        return False;
    return True;
  @staticmethod
  def slice_3(__self: list[int], start: int, end: int) -> list[int]:
    res = []
    __len = len(__self)
    _from = start
    to = end
    if _from < 0:
      _from = 0;
    if to > __len:
      to = __len;
    i_2 = _from
    while i_2 < to:
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    return res;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 4;
  }
}) ) {
  System.out.println(String.valueOf( "one item is greater than four" ) );
}
if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 0;
  }
}) ) {
  System.out.println(String.valueOf( "every item is positive" ) );
}
final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
System.out.println(String.valueOf( "part " + part.size() ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
    if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 4;
      }
    }) ) {
      System.out.println(String.valueOf( "one item is greater than four" ) );
    }
    if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 0;
      }
    }) ) {
      System.out.println(String.valueOf( "every item is positive" ) );
    }
    final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
    System.out.println(String.valueOf( "part " + part.size() ) );
  }
}


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


public interface LambdaSignature1 {
  public Boolean run( final Integer item);
}


import java.util.*;

public class operatorsOf {

  public static Boolean any_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it : __self) {
      if ( cb.run(it) ) {
        return true;
      }
    }
    return false;
  }

  public static Boolean all_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it_1 : __self) {
      if ( cb.run(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  public static ArrayList<Integer> slice_3( final ArrayList<Integer> __self , final Integer start , final Integer end ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final Integer __len = __self.size();
    Integer from = start;
    Integer to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    Integer i_2 = from;
    while (i_2 < to) {
      res.add(__self.get(i_2));
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Kotlin

main function, Kotlin

__g_args = args
val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
  return item > 4;
}) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
  return item > 0;
}) ) {
  println( "every item is positive" )
}
val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
println( "part " + (part.size).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
  if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
    return item > 4;
  }) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
    return item > 0;
  }) ) {
    println( "every item is positive" )
  }
  val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
  println( "part " + (part.size).toString() )
}

class operatorsOf
 {
  companion object {

    fun  any_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it in __self ) {
        if ( cb(it) ) {
          return true;
        }
      }
      return false;
    }

    fun  all_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it_1 in __self ) {
        if ( cb(it_1) == false ) {
          return false;
        }
      }
      return true;
    }

    fun  slice_3( __self : MutableList<Int>, start : Int, end : Int) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val __len : Int  = __self.size;
      var from : Int  = start;
      var to : Int  = end;
      if ( from < 0 ) {
        from = 0;
      }
      if ( to > __len ) {
        to = __len;
      }
      var i_2 : Int  = from;
      while (i_2 < to) {
        res.add(__self[i_2]);
        i_2 = i_2 + 1;
      }
      return res;
    }
  }
}

Dart

main function, Dart

__g_args = args;
List<int> numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, (item) {
  return item > 4;
}
) ) {
  print( "one item is greater than four" );
}
if ( operatorsOf.all_2(numbers, (item) {
  return item > 0;
}
) ) {
  print( "every item is positive" );
}
List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
print( "part " + (_part.length).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, (item) {
    return item > 4;
  }
  ) ) {
    print( "one item is greater than four" );
  }
  if ( operatorsOf.all_2(numbers, (item) {
    return item > 0;
  }
  ) ) {
    print( "every item is positive" );
  }
  List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
  print( "part " + (_part.length).toString() );
}

class operatorsOf {

  static bool any_2(List<int> __self, bool Function(int) cb) {
    for ( final it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }

  static bool all_2(List<int> __self, bool Function(int) cb) {
    for ( final it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  static List<int> slice_3(List<int> __self, int start, int end) {
    List<int> res = [];
    int __len = __self.length;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Swift

main function, Swift

let numbers : [Int] = [1, 2, 3, 4, 5]
if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 4
})) ) {
  print("one item is greater than four")
}
if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 0
})) ) {
  print("every item is positive")
}
let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
print("part " + String(part.count))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func any_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it in __self {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  class func all_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it_1 in __self {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  class func slice_3(__self : [Int], start : Int, end : Int) -> [Int] {
    var res : [Int] = [Int]()
    let __len : Int = __self.count
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    var i_2 : Int = from
    while (i_2 < to) {
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    }
    return res
  }
}
// Main entry point
func __main__swift() {
  let numbers : [Int] = [1, 2, 3, 4, 5]
  if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 4
  })) ) {
    print("one item is greater than four")
  }
  if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 0
  })) ) {
    print("every item is positive")
  }
  let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
  print("part " + String(part.count))
}
__main__swift()

C#

main function, C#

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
  return item > 4;
}))) ) {
  Console.WriteLine("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
  return item > 0;
}))) ) {
  Console.WriteLine("every item is positive");
}
List<int> part = operatorsOf.slice_3(numbers, 1, 3);
Console.WriteLine("part " + part.Count);

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> {1, 2, 3, 4, 5};
    if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
      return item > 4;
    }))) ) {
      Console.WriteLine("one item is greater than four");
    }
    if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
      return item > 0;
    }))) ) {
      Console.WriteLine("every item is positive");
    }
    List<int> part = operatorsOf.slice_3(numbers, 1, 3);
    Console.WriteLine("part " + part.Count);
  }
}
class operatorsOf  {
  public static bool any_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }
  public static bool all_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static List<int> slice_3( List<int> __self , int start , int end ) {
    List<int> res = new List<int>();
    int __len = __self.Count;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.Add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

C++

main function, C++

std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
if ( operatorsOf::any_2(numbers, [&](int item) mutable {
  return item > 4;
}) ) {
  std::cout << std::string("one item is greater than four") << std::endl;
}
if ( operatorsOf::all_2(numbers, [&](int item) mutable {
  return item > 0;
}) ) {
  std::cout << std::string("every item is positive") << std::endl;
}
std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
return 0;

The complete file

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

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



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static bool any_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static bool all_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static std::vector<int> slice_3( const std::vector<int>& __self , int start , int end );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
  if ( operatorsOf::any_2(numbers, [&](int item) mutable {
    return item > 4;
  }) ) {
    std::cout << std::string("one item is greater than four") << std::endl;
  }
  if ( operatorsOf::all_2(numbers, [&](int item) mutable {
    return item > 0;
  }) ) {
    std::cout << std::string("every item is positive") << std::endl;
  }
  std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
  std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
bool  operatorsOf::any_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it : __self ) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
}
bool  operatorsOf::all_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it_1 : __self ) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
}
std::vector<int>  operatorsOf::slice_3( const std::vector<int>& __self , int start , int end ) {
  std::vector<int> res;
  int __len = (int)(__self.size());
  int from = start;
  int to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  int i_2 = from;
  while (i_2 < to) {
    res.push_back( __self.at(i_2)  );
    i_2 = i_2 + 1;
  };
  return res;
}

PHP

main function, PHP

$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

Scala

main function, Scala

val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
  println( "every item is positive" )
}
val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
println( "part " + part.length )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  any_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it <- __self ) {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  def  all_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it_1 <- __self ) {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  def  slice_3( __self : collection.mutable.ArrayBuffer[Int], start : Int, end : Int) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val __len : Int = __self.length
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0
    }
    if ( to > __len ) {
      to = __len
    }
    var i_2 : Int = from
    try {
      val __break__ = new Breaks;
      __break__.breakable {
        while (i_2 < to) {
          val __continue__ = new Breaks;
          __continue__.breakable {
            res.append(__self(i_2))
            i_2 = i_2 + 1
          }
        }
      }
    }
    return res
  }
}

// application main function for Main
object AppMain extends App {
  val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
  if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
    println( "every item is positive" )
  }
  val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
  println( "part " + part.length )
}

The Ranger source of the method

fn all:boolean (cb:(_:boolean (item:T))) @doc('True when `cb` holds for every item (true when empty)') {
    for self it@(lives):T i {
        if( (cb(it)) == false )  {
            return false
        }
    }
    return true
}

Definition: lib/stdlib.rgr, line 826

any

receiver.any(cb) → boolean

any(cb: (fn:boolean (item:T)))

True when `cb` holds for at least one item

The compiler writes this method for every target.

Test the items of an array and take a part of it

docs/examples/lib/stdlib/tests-and-slice.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def numbers:[int] ([] _:int (1 2 3 4 5))
        if (numbers.any({ return (item > 4) })) {
            print "one item is greater than four"
        }
        if (numbers.all({ return (item > 0) })) {
            print "every item is positive"
        }
        def part (numbers.slice(1 3))
        print ("part " + (array_length part))
    }
}

JavaScript

main function, JavaScript

const numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item) => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item) => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.any_2 = function(__self, cb) {
  for ( const it of __self) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
};
operatorsOf.all_2 = function(__self, cb) {
  for ( const it_1 of __self) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
};
operatorsOf.slice_3 = function(__self, start, end) {
  let res = [];
  const __len = __self.length;
  let from = start;
  let to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  let i_2 = from;
  while (i_2 < to) {
    res.push(__self[i_2]);
    i_2 = i_2 + 1;
  };
  return res;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item) => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item) => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

TypeScript

main function, TypeScript

const numbers : Array<number>  = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static any_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it of __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  };
  static all_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it_1 of __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  };
  static slice_3 (__self : Array<number>, start : number, end : number) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const __len : number  = __self.length;
    let from : number  = start;
    let to : number  = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    let i_2 : number  = from;
    while (i_2 < to) {
      res.push(__self[i_2]);
      i_2 = i_2 + 1;
    };
    return res;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers : Array<number>  = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

Go

main function, Go

var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
if  operatorsOf_static_any_2(numbers, func (item int64) bool {
  return item > int64(4)
}) {
  fmt.Println( "one item is greater than four" )
}
if  operatorsOf_static_all_2(numbers, func (item int64) bool {
  return item > int64(0)
}) {
  fmt.Println( "every item is positive" )
}
var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )

The complete file

package main
import (
  "fmt"
  "strings"
  "strconv"
)
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
  if  operatorsOf_static_any_2(numbers, func (item int64) bool {
    return item > int64(4)
  }) {
    fmt.Println( "one item is greater than four" )
  }
  if  operatorsOf_static_all_2(numbers, func (item int64) bool {
    return item > int64(0)
  }) {
    fmt.Println( "every item is positive" )
  }
  var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
  fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_any_2(__self []int64, cb func(int64) bool) bool {
  for _, it := range __self {
    if  cb(it) {
      return true
    }
  }
  return false
}
func operatorsOf_static_all_2(__self []int64, cb func(int64) bool) bool {
  for _, it_1 := range __self {
    if  cb(it_1) == false {
      return false
    }
  }
  return true
}
func operatorsOf_static_slice_3(__self []int64, start int64, end int64) []int64 {
  var res []int64 = make([]int64, 0);
  var __len int64= int64(len(__self));
  var from int64= start;
  var to int64= end;
  if  from < int64(0) {
    from = int64(0);
  }
  if  to > __len {
    to = __len;
  }
  var i_2 int64= from;
  for i_2 < to {
    res = append(res,__self[i_2]);
    i_2 = i_2 + int64(1);
  }
  return res
}

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)]
#![allow(unused_mut)]

#[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![1, 2, 3, 4, 5];
  if  operatorsOf::any_2(&numbers, &mut |mut item| {
    return item > 4;
  }) {
    println!("one item is greater than four");
  }
  if  operatorsOf::all_2(&numbers, &mut |mut item| {
    return item > 0;
  }) {
    println!("every item is positive");
  }
  let mut part: Vec<i64> = operatorsOf::slice_3(&numbers, 1, 3);
  println!("part {}", part.len() as i64);
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn any_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it in __self.iter().copied() {
      if  cb(it) {
        return true;
      }
    }
    false
  }
  pub fn all_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it_1 in __self.iter().copied() {
      if  !(cb(it_1)) {
        return false;
      }
    }
    true
  }
  pub fn slice_3(__self: &[i64], start: i64, end: i64) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let __len: i64 = __self.len() as i64;
    let mut from: i64 = start;
    let mut to: i64 = end;
    if  from < 0 {
      from = 0;
    }
    if  to > __len {
      to = __len;
    }
    let mut i_2: i64 = from;
    while i_2 < to {
      res.push(__self[(i_2) as usize]);
      i_2 += 1;
    };
    res.clone()
  }
}

Python

main function, Python

def __rg_lambda_1(item):
  return item > 4;
def __rg_lambda_2(item):
  return item > 0;
numbers = [1, 2, 3, 4, 5]
if operatorsOf.any_2(numbers, __rg_lambda_1):
  print("one item is greater than four")
if operatorsOf.all_2(numbers, __rg_lambda_2):
  print("every item is positive")
part = operatorsOf.slice_3(numbers, 1, 3)
print("part " + str(len(part)))

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():
  def __rg_lambda_1(item):
    return item > 4;
  def __rg_lambda_2(item):
    return item > 0;
  numbers = [1, 2, 3, 4, 5]
  if operatorsOf.any_2(numbers, __rg_lambda_1):
    print("one item is greater than four")
  if operatorsOf.all_2(numbers, __rg_lambda_2):
    print("every item is positive")
  part = operatorsOf.slice_3(numbers, 1, 3)
  print("part " + str(len(part)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def any_2(__self: list[int], cb) -> bool:
    for it in __self:
      if cb(it):
        return True;
    return False;
  @staticmethod
  def all_2(__self: list[int], cb) -> bool:
    for it_1 in __self:
      if cb(it_1) == False:
        return False;
    return True;
  @staticmethod
  def slice_3(__self: list[int], start: int, end: int) -> list[int]:
    res = []
    __len = len(__self)
    _from = start
    to = end
    if _from < 0:
      _from = 0;
    if to > __len:
      to = __len;
    i_2 = _from
    while i_2 < to:
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    return res;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 4;
  }
}) ) {
  System.out.println(String.valueOf( "one item is greater than four" ) );
}
if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 0;
  }
}) ) {
  System.out.println(String.valueOf( "every item is positive" ) );
}
final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
System.out.println(String.valueOf( "part " + part.size() ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
    if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 4;
      }
    }) ) {
      System.out.println(String.valueOf( "one item is greater than four" ) );
    }
    if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 0;
      }
    }) ) {
      System.out.println(String.valueOf( "every item is positive" ) );
    }
    final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
    System.out.println(String.valueOf( "part " + part.size() ) );
  }
}


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


public interface LambdaSignature1 {
  public Boolean run( final Integer item);
}


import java.util.*;

public class operatorsOf {

  public static Boolean any_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it : __self) {
      if ( cb.run(it) ) {
        return true;
      }
    }
    return false;
  }

  public static Boolean all_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it_1 : __self) {
      if ( cb.run(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  public static ArrayList<Integer> slice_3( final ArrayList<Integer> __self , final Integer start , final Integer end ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final Integer __len = __self.size();
    Integer from = start;
    Integer to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    Integer i_2 = from;
    while (i_2 < to) {
      res.add(__self.get(i_2));
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Kotlin

main function, Kotlin

__g_args = args
val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
  return item > 4;
}) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
  return item > 0;
}) ) {
  println( "every item is positive" )
}
val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
println( "part " + (part.size).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
  if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
    return item > 4;
  }) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
    return item > 0;
  }) ) {
    println( "every item is positive" )
  }
  val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
  println( "part " + (part.size).toString() )
}

class operatorsOf
 {
  companion object {

    fun  any_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it in __self ) {
        if ( cb(it) ) {
          return true;
        }
      }
      return false;
    }

    fun  all_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it_1 in __self ) {
        if ( cb(it_1) == false ) {
          return false;
        }
      }
      return true;
    }

    fun  slice_3( __self : MutableList<Int>, start : Int, end : Int) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val __len : Int  = __self.size;
      var from : Int  = start;
      var to : Int  = end;
      if ( from < 0 ) {
        from = 0;
      }
      if ( to > __len ) {
        to = __len;
      }
      var i_2 : Int  = from;
      while (i_2 < to) {
        res.add(__self[i_2]);
        i_2 = i_2 + 1;
      }
      return res;
    }
  }
}

Dart

main function, Dart

__g_args = args;
List<int> numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, (item) {
  return item > 4;
}
) ) {
  print( "one item is greater than four" );
}
if ( operatorsOf.all_2(numbers, (item) {
  return item > 0;
}
) ) {
  print( "every item is positive" );
}
List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
print( "part " + (_part.length).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, (item) {
    return item > 4;
  }
  ) ) {
    print( "one item is greater than four" );
  }
  if ( operatorsOf.all_2(numbers, (item) {
    return item > 0;
  }
  ) ) {
    print( "every item is positive" );
  }
  List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
  print( "part " + (_part.length).toString() );
}

class operatorsOf {

  static bool any_2(List<int> __self, bool Function(int) cb) {
    for ( final it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }

  static bool all_2(List<int> __self, bool Function(int) cb) {
    for ( final it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  static List<int> slice_3(List<int> __self, int start, int end) {
    List<int> res = [];
    int __len = __self.length;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Swift

main function, Swift

let numbers : [Int] = [1, 2, 3, 4, 5]
if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 4
})) ) {
  print("one item is greater than four")
}
if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 0
})) ) {
  print("every item is positive")
}
let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
print("part " + String(part.count))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func any_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it in __self {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  class func all_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it_1 in __self {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  class func slice_3(__self : [Int], start : Int, end : Int) -> [Int] {
    var res : [Int] = [Int]()
    let __len : Int = __self.count
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    var i_2 : Int = from
    while (i_2 < to) {
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    }
    return res
  }
}
// Main entry point
func __main__swift() {
  let numbers : [Int] = [1, 2, 3, 4, 5]
  if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 4
  })) ) {
    print("one item is greater than four")
  }
  if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 0
  })) ) {
    print("every item is positive")
  }
  let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
  print("part " + String(part.count))
}
__main__swift()

C#

main function, C#

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
  return item > 4;
}))) ) {
  Console.WriteLine("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
  return item > 0;
}))) ) {
  Console.WriteLine("every item is positive");
}
List<int> part = operatorsOf.slice_3(numbers, 1, 3);
Console.WriteLine("part " + part.Count);

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> {1, 2, 3, 4, 5};
    if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
      return item > 4;
    }))) ) {
      Console.WriteLine("one item is greater than four");
    }
    if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
      return item > 0;
    }))) ) {
      Console.WriteLine("every item is positive");
    }
    List<int> part = operatorsOf.slice_3(numbers, 1, 3);
    Console.WriteLine("part " + part.Count);
  }
}
class operatorsOf  {
  public static bool any_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }
  public static bool all_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static List<int> slice_3( List<int> __self , int start , int end ) {
    List<int> res = new List<int>();
    int __len = __self.Count;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.Add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

C++

main function, C++

std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
if ( operatorsOf::any_2(numbers, [&](int item) mutable {
  return item > 4;
}) ) {
  std::cout << std::string("one item is greater than four") << std::endl;
}
if ( operatorsOf::all_2(numbers, [&](int item) mutable {
  return item > 0;
}) ) {
  std::cout << std::string("every item is positive") << std::endl;
}
std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
return 0;

The complete file

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

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



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static bool any_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static bool all_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static std::vector<int> slice_3( const std::vector<int>& __self , int start , int end );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
  if ( operatorsOf::any_2(numbers, [&](int item) mutable {
    return item > 4;
  }) ) {
    std::cout << std::string("one item is greater than four") << std::endl;
  }
  if ( operatorsOf::all_2(numbers, [&](int item) mutable {
    return item > 0;
  }) ) {
    std::cout << std::string("every item is positive") << std::endl;
  }
  std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
  std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
bool  operatorsOf::any_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it : __self ) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
}
bool  operatorsOf::all_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it_1 : __self ) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
}
std::vector<int>  operatorsOf::slice_3( const std::vector<int>& __self , int start , int end ) {
  std::vector<int> res;
  int __len = (int)(__self.size());
  int from = start;
  int to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  int i_2 = from;
  while (i_2 < to) {
    res.push_back( __self.at(i_2)  );
    i_2 = i_2 + 1;
  };
  return res;
}

PHP

main function, PHP

$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

Scala

main function, Scala

val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
  println( "every item is positive" )
}
val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
println( "part " + part.length )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  any_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it <- __self ) {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  def  all_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it_1 <- __self ) {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  def  slice_3( __self : collection.mutable.ArrayBuffer[Int], start : Int, end : Int) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val __len : Int = __self.length
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0
    }
    if ( to > __len ) {
      to = __len
    }
    var i_2 : Int = from
    try {
      val __break__ = new Breaks;
      __break__.breakable {
        while (i_2 < to) {
          val __continue__ = new Breaks;
          __continue__.breakable {
            res.append(__self(i_2))
            i_2 = i_2 + 1
          }
        }
      }
    }
    return res
  }
}

// application main function for Main
object AppMain extends App {
  val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
  if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
    println( "every item is positive" )
  }
  val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
  println( "part " + part.length )
}

The Ranger source of the method

fn any:boolean (cb:(_:boolean (item:T))) @doc('True when `cb` holds for at least one item') {
    for self it@(lives):T i {
        if( cb(it) )  {
            return true
        }
    }
    return false
}

Definition: lib/stdlib.rgr, line 817

clone

receiver.clone() → [T]

The compiler writes this method for every target.

The Ranger source of the method

fn clone:[T] () {
    def res:[T]
    for self it:T i {
        push res it
    }
    return res
}

Definition: lib/stdlib.rgr, line 776

contains

receiver.contains(cb) → boolean

contains(cb: (fn:boolean (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn contains:boolean (cb:(_:boolean (item:T))) {
    for self it@(lives):T i {
        if( cb(it) )  {
            return true
        }
    }
    return false
}

Definition: lib/stdlib.rgr, line 808

count

receiver.count(cb) → int

count(cb: (fn:boolean (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn count:int (cb:(_:boolean (item:T))) {
    def res 0
    for self it@(lives):T i {
        if( cb(it) )  {
            res = res + 1
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 798

filter

receiver.filter(cb) → [T]

filter(cb: (fn:boolean (item:T index:int)))

The compiler writes this method for every target.

Change and select the items of an array

docs/examples/lib/stdlib/collection-methods.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def numbers:[int] ([] _:int (1 2 3 4 5))
        def doubled (numbers.map({ return (item * 2) }))
        def large (numbers.filter({ return (item > 3) }))
        print ("doubled " + (array_length doubled))
        print ("large " + (array_length large))
    }
}

JavaScript

main function, JavaScript

const numbers = [1, 2, 3, 4, 5];
const doubled = operatorsOf.map_2(numbers, ((item, index) => {
  return item * 2;
}));
const large = operatorsOf.filter_3(numbers, ((item, index) => {
  return item > 3;
}));
console.log("doubled " + doubled.length);
console.log("large " + large.length);

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.map_2 = function(__self, cb) {
  const __len = __self.length;
  let res = [];
  for ( let i = 0; i < __self.length; i++) {
    var it = __self[i];
    res.push(cb(it, i));
  }
  return res;
};
operatorsOf.filter_3 = function(__self, cb) {
  let res_1 = [];
  for ( let i_1 = 0; i_1 < __self.length; i_1++) {
    var it_1 = __self[i_1];
    if ( cb(it_1, i_1) ) {
      res_1.push(it_1);
    }
  }
  return res_1;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers = [1, 2, 3, 4, 5];
  const doubled = operatorsOf.map_2(numbers, ((item, index) => {
    return item * 2;
  }));
  const large = operatorsOf.filter_3(numbers, ((item, index) => {
    return item > 3;
  }));
  console.log("doubled " + doubled.length);
  console.log("large " + large.length);
}
__js_main();

TypeScript

main function, TypeScript

const numbers : Array<number>  = [1, 2, 3, 4, 5];
const doubled : Array<number>  = operatorsOf.map_2(numbers, ((item : number, index : number):number => {
  return item * 2;
}));
const large : Array<number>  = operatorsOf.filter_3(numbers, ((item : number, index : number):boolean => {
  return item > 3;
}));
console.log("doubled " + doubled.length);
console.log("large " + large.length);

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static map_2 (__self : Array<number>, cb : (item:number, index:number) => number) : Array<number>  {
    const __len : number  = __self.length;
    let res : Array<number> | undefined  = [];
    for ( let i = 0; i < __self.length; i++) {
      var it = __self[i];
      res.push(cb(it, i));
    }
    return res;
  };
  static filter_3 (__self : Array<number>, cb : (item:number, index:number) => boolean) : Array<number>  {
    let res_1 : Array<number> | undefined  = [];
    for ( let i_1 = 0; i_1 < __self.length; i_1++) {
      var it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.push(it_1);
      }
    }
    return res_1;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers : Array<number>  = [1, 2, 3, 4, 5];
  const doubled : Array<number>  = operatorsOf.map_2(numbers, ((item : number, index : number):number => {
    return item * 2;
  }));
  const large : Array<number>  = operatorsOf.filter_3(numbers, ((item : number, index : number):boolean => {
    return item > 3;
  }));
  console.log("doubled " + doubled.length);
  console.log("large " + large.length);
}
__js_main();

Go

main function, Go

var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
var doubled []int64= operatorsOf_static_map_2(numbers, func (item int64, index int64) int64 {
  return item * int64(2)
});
var large []int64= operatorsOf_static_filter_3(numbers, func (item int64, index int64) bool {
  return item > int64(3)
});
fmt.Println( strings.Join([]string{ "doubled ",strconv.FormatInt(int64(len(doubled)), 10) }, "") )
fmt.Println( strings.Join([]string{ "large ",strconv.FormatInt(int64(len(large)), 10) }, "") )

The complete file

package main
import (
  "strings"
  "strconv"
  "fmt"
)
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
  var doubled []int64= operatorsOf_static_map_2(numbers, func (item int64, index int64) int64 {
    return item * int64(2)
  });
  var large []int64= operatorsOf_static_filter_3(numbers, func (item int64, index int64) bool {
    return item > int64(3)
  });
  fmt.Println( strings.Join([]string{ "doubled ",strconv.FormatInt(int64(len(doubled)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "large ",strconv.FormatInt(int64(len(large)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_map_2(__self []int64, cb func(int64, int64) int64) []int64 {
  /* unused:  __len*/
  var res []int64 = make([]int64, 0);
  var i int64 = 0;
  for ; i < int64(len(__self)) ; i++ {
    it := __self[i]
    res = append(res,cb(it, i));
  }
  return res
}
func operatorsOf_static_filter_3(__self []int64, cb func(int64, int64) bool) []int64 {
  var res_1 []int64 = make([]int64, 0);
  var i_1 int64 = 0;
  for ; i_1 < int64(len(__self)) ; i_1++ {
    it_1 := __self[i_1]
    if  cb(it_1, i_1) {
      res_1 = append(res_1,it_1);
    }
  }
  return res_1
}

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)]
#![allow(unused_mut)]

#[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![1, 2, 3, 4, 5];
  let mut doubled: Vec<i64> = operatorsOf::map_2(&numbers, &mut |mut item, mut index| {
    return item * 2;
  });
  let mut large: Vec<i64> = operatorsOf::filter_3(&numbers, &mut |mut item, mut index| {
    return item > 3;
  });
  println!("doubled {}", doubled.len() as i64);
  println!("large {}", large.len() as i64);
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn map_2(__self: &[i64], cb: &mut dyn FnMut(i64, i64) -> i64) -> Vec<i64> {
    // unused:  let __len: i64 = __self.len() as i64;
    let mut res: Vec<i64> = Vec::new();
    let __n_i = __self.len() as i64;
    for i in 0..__n_i {
      let mut it = __self[i as usize];
      res.push(cb(it, i.clone()));
    }
    res.clone()
  }
  pub fn filter_3(__self: &[i64], cb: &mut dyn FnMut(i64, i64) -> bool) -> Vec<i64> {
    let mut res_1: Vec<i64> = Vec::new();
    let __n_i = __self.len() as i64;
    for i_1 in 0..__n_i {
      let mut it_1 = __self[i_1 as usize];
      if  cb(it_1, i_1.clone()) {
        res_1.push(it_1);
      }
    }
    res_1.clone()
  }
}

Python

main function, Python

def __rg_lambda_1(item, index):
  return item * 2;
def __rg_lambda_2(item, index):
  return item > 3;
numbers = [1, 2, 3, 4, 5]
doubled = operatorsOf.map_2(numbers, __rg_lambda_1)
large = operatorsOf.filter_3(numbers, __rg_lambda_2)
print("doubled " + str(len(doubled)))
print("large " + str(len(large)))

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():
  def __rg_lambda_1(item, index):
    return item * 2;
  def __rg_lambda_2(item, index):
    return item > 3;
  numbers = [1, 2, 3, 4, 5]
  doubled = operatorsOf.map_2(numbers, __rg_lambda_1)
  large = operatorsOf.filter_3(numbers, __rg_lambda_2)
  print("doubled " + str(len(doubled)))
  print("large " + str(len(large)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def map_2(__self: list[int], cb) -> list[int]:
    pass  # unused:  __len = len(__self)
    res = []
    for i, it in enumerate(__self):
      res.append(cb(it, i))
    return res;
  @staticmethod
  def filter_3(__self: list[int], cb) -> list[int]:
    res_1 = []
    for i_1, it_1 in enumerate(__self):
      if cb(it_1, i_1):
        res_1.append(it_1)
    return res_1;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
final ArrayList<Integer> doubled = operatorsOf.map_2(numbers, new LambdaSignature1() {
  public Integer run( final Integer item,  final Integer index) {
    return item * 2;
  }
});
final ArrayList<Integer> large = operatorsOf.filter_3(numbers, new LambdaSignature2() {
  public Boolean run( final Integer item,  final Integer index) {
    return item > 3;
  }
});
System.out.println(String.valueOf( "doubled " + doubled.size() ) );
System.out.println(String.valueOf( "large " + large.size() ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
    final ArrayList<Integer> doubled = operatorsOf.map_2(numbers, new LambdaSignature1() {
      public Integer run( final Integer item,  final Integer index) {
        return item * 2;
      }
    });
    final ArrayList<Integer> large = operatorsOf.filter_3(numbers, new LambdaSignature2() {
      public Boolean run( final Integer item,  final Integer index) {
        return item > 3;
      }
    });
    System.out.println(String.valueOf( "doubled " + doubled.size() ) );
    System.out.println(String.valueOf( "large " + large.size() ) );
  }
}


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


public interface LambdaSignature1 {
  public Integer run( final Integer item,  final Integer index);
}


public interface LambdaSignature2 {
  public Boolean run( final Integer item,  final Integer index);
}


import java.util.*;

public class operatorsOf {

  public static ArrayList<Integer> map_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    /* unused:  final Integer __len = __self.size()   **/ ;
    ArrayList<Integer> res = new ArrayList<Integer>();
    for ( int i = 0; i < __self.size(); i++) {
      Integer it = __self.get(i);
      res.add(cb.run(it, i));
    }
    return res;
  }

  public static ArrayList<Integer> filter_3( final ArrayList<Integer> __self , final LambdaSignature2 cb ) {
    ArrayList<Integer> res_1 = new ArrayList<Integer>();
    for ( int i_1 = 0; i_1 < __self.size(); i_1++) {
      Integer it_1 = __self.get(i_1);
      if ( cb.run(it_1, i_1) ) {
        res_1.add(it_1);
      }
    }
    return res_1;
  }
}

Kotlin

main function, Kotlin

__g_args = args
val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
val doubled : MutableList<Int>  = operatorsOf.map_2(numbers, fun(item : Int, index : Int) : Int {
  return item * 2;
});
val large : MutableList<Int>  = operatorsOf.filter_3(numbers, fun(item : Int, index : Int) : Boolean {
  return item > 3;
});
println( "doubled " + (doubled.size).toString() )
println( "large " + (large.size).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
  val doubled : MutableList<Int>  = operatorsOf.map_2(numbers, fun(item : Int, index : Int) : Int {
    return item * 2;
  });
  val large : MutableList<Int>  = operatorsOf.filter_3(numbers, fun(item : Int, index : Int) : Boolean {
    return item > 3;
  });
  println( "doubled " + (doubled.size).toString() )
  println( "large " + (large.size).toString() )
}

class operatorsOf
 {
  companion object {

    fun  map_2( __self : MutableList<Int>, cb : (Int, Int) -> Int) : MutableList<Int> {
      /* unused:  val __len : Int  = __self.size   **/ ;
      var res : MutableList<Int>  = arrayListOf();
      for ( i in __self.indices ) {
        val it = __self[i]
        res.add(cb(it, i));
      }
      return res;
    }

    fun  filter_3( __self : MutableList<Int>, cb : (Int, Int) -> Boolean) : MutableList<Int> {
      var res_1 : MutableList<Int>  = arrayListOf();
      for ( i_1 in __self.indices ) {
        val it_1 = __self[i_1]
        if ( cb(it_1, i_1) ) {
          res_1.add(it_1);
        }
      }
      return res_1;
    }
  }
}

Dart

main function, Dart

__g_args = args;
List<int> numbers = [1, 2, 3, 4, 5];
List<int> doubled = operatorsOf.map_2(numbers, (item, index) {
  return item * 2;
}
);
List<int> large = operatorsOf.filter_3(numbers, (item, index) {
  return item > 3;
}
);
print( "doubled " + (doubled.length).toString() );
print( "large " + (large.length).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [1, 2, 3, 4, 5];
  List<int> doubled = operatorsOf.map_2(numbers, (item, index) {
    return item * 2;
  }
  );
  List<int> large = operatorsOf.filter_3(numbers, (item, index) {
    return item > 3;
  }
  );
  print( "doubled " + (doubled.length).toString() );
  print( "large " + (large.length).toString() );
}

class operatorsOf {

  static List<int> map_2(List<int> __self, int Function(int, int) cb) {
    /* unused:  int __len = __self.length   */
    List<int> res = [];
    for ( int i = 0; i < __self.length; i++) {
      var it = __self[i];
      res.add(cb(it, i));
    }
    return res;
  }

  static List<int> filter_3(List<int> __self, bool Function(int, int) cb) {
    List<int> res_1 = [];
    for ( int i_1 = 0; i_1 < __self.length; i_1++) {
      var it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.add(it_1);
      }
    }
    return res_1;
  }
}

Swift

main function, Swift

let numbers : [Int] = [1, 2, 3, 4, 5]
let doubled : [Int] = operatorsOf.map_2(__self : numbers, cb : ({ (item, index) ->  Int in
  return item * 2
}))
let large : [Int] = operatorsOf.filter_3(__self : numbers, cb : ({ (item, index) ->  Bool in
  return item > 3
}))
print("doubled " + String(doubled.count))
print("large " + String(large.count))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func map_2(__self : [Int], cb :   @escaping  (( _ : Int,  _ : Int) -> Int)) -> [Int] {
    /* unused:  let __len : Int = __self.count   **/
    var res : [Int] = [Int]()
    for (i, it) in __self.enumerated() {
      res.append(cb(it, i))
    }
    return res
  }
  class func filter_3(__self : [Int], cb :   @escaping  (( _ : Int,  _ : Int) -> Bool)) -> [Int] {
    var res_1 : [Int] = [Int]()
    for (i_1, it_1) in __self.enumerated() {
      if ( cb(it_1, i_1) ) {
        res_1.append(it_1)
      }
    }
    return res_1
  }
}
// Main entry point
func __main__swift() {
  let numbers : [Int] = [1, 2, 3, 4, 5]
  let doubled : [Int] = operatorsOf.map_2(__self : numbers, cb : ({ (item, index) ->  Int in
    return item * 2
  }))
  let large : [Int] = operatorsOf.filter_3(__self : numbers, cb : ({ (item, index) ->  Bool in
    return item > 3
  }))
  print("doubled " + String(doubled.count))
  print("large " + String(large.count))
}
__main__swift()

C#

main function, C#

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
List<int> doubled = operatorsOf.map_2(numbers, ((Func<int, int, int>)((item, index) => {
  return item * 2;
})));
List<int> large = operatorsOf.filter_3(numbers, ((Func<int, int, bool>)((item, index) => {
  return item > 3;
})));
Console.WriteLine("doubled " + doubled.Count);
Console.WriteLine("large " + large.Count);

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> {1, 2, 3, 4, 5};
    List<int> doubled = operatorsOf.map_2(numbers, ((Func<int, int, int>)((item, index) => {
      return item * 2;
    })));
    List<int> large = operatorsOf.filter_3(numbers, ((Func<int, int, bool>)((item, index) => {
      return item > 3;
    })));
    Console.WriteLine("doubled " + doubled.Count);
    Console.WriteLine("large " + large.Count);
  }
}
class operatorsOf  {
  public static List<int> map_2( List<int> __self , Func<int, int, int> cb ) {
    /* unused:  int __len = __self.Count   **/ ;
    List<int> res = new List<int>();
    for ( int i = 0; i < __self.Count; i++) {
      int it = __self[i];
      res.Add(cb(it, i));
    }
    return res;
  }
  public static List<int> filter_3( List<int> __self , Func<int, int, bool> cb ) {
    List<int> res_1 = new List<int>();
    for ( int i_1 = 0; i_1 < __self.Count; i_1++) {
      int it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.Add(it_1);
      }
    }
    return res_1;
  }
}

C++

main function, C++

std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
std::vector<int> doubled = operatorsOf::map_2(numbers, [&](int item, int index) mutable {
  return item * 2;
});
std::vector<int> large = operatorsOf::filter_3(numbers, [&](int item, int index) mutable {
  return item > 3;
});
std::cout << std::string("doubled ") + std::to_string((int)(doubled.size())) << std::endl;
std::cout << std::string("large ") + std::to_string((int)(large.size())) << std::endl;
return 0;

The complete file

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

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



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static std::vector<int> map_2( const std::vector<int>& __self , std::function<int(int, int)> cb );
    static std::vector<int> filter_3( const std::vector<int>& __self , std::function<bool(int, int)> cb );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
  std::vector<int> doubled = operatorsOf::map_2(numbers, [&](int item, int index) mutable {
    return item * 2;
  });
  std::vector<int> large = operatorsOf::filter_3(numbers, [&](int item, int index) mutable {
    return item > 3;
  });
  std::cout << std::string("doubled ") + std::to_string((int)(doubled.size())) << std::endl;
  std::cout << std::string("large ") + std::to_string((int)(large.size())) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
std::vector<int>  operatorsOf::map_2( const std::vector<int>& __self , std::function<int(int, int)> cb ) {
  /* unused:  int __len = (int)(__self.size())   **/ ;
  std::vector<int> res;
  for ( int i = 0; i != (int)(__self.size()); i++) {
    int it = __self.at(i);
    res.push_back( cb(it, i)  );
  }
  return res;
}
std::vector<int>  operatorsOf::filter_3( const std::vector<int>& __self , std::function<bool(int, int)> cb ) {
  std::vector<int> res_1;
  for ( int i_1 = 0; i_1 != (int)(__self.size()); i_1++) {
    int it_1 = __self.at(i_1);
    if ( cb(it_1, i_1) ) {
      res_1.push_back( it_1  );
    }
  }
  return res_1;
}

PHP

main function, PHP

$numbers = array(1, 2, 3, 4, 5);
$doubled = operatorsOf::map_2($numbers, (function ($item, $index)  {
  return $item * 2;
}));
$large = operatorsOf::filter_3($numbers, (function ($item, $index)  {
  return $item > 3;
}));
echo( "doubled " . count($doubled) . "\n");
echo( "large " . count($large) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function map_2( $__self , $cb ) {
    /* unused:  $__len = count($__self)   **/ ;
    $res = array();
    for ( $i = 0; $i < count($__self); $i++) {
      $it = $__self[$i];
      array_push($res, call_user_func($cb, $it, $i));
    }
    return $res;
  }
  public static function filter_3( $__self , $cb ) {
    $res_1 = array();
    for ( $i_1 = 0; $i_1 < count($__self); $i_1++) {
      $it_1 = $__self[$i_1];
      if ( call_user_func($cb, $it_1, $i_1) ) {
        array_push($res_1, $it_1);
      }
    }
    return $res_1;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array(1, 2, 3, 4, 5);
$doubled = operatorsOf::map_2($numbers, (function ($item, $index)  {
  return $item * 2;
}));
$large = operatorsOf::filter_3($numbers, (function ($item, $index)  {
  return $item > 3;
}));
echo( "doubled " . count($doubled) . "\n");
echo( "large " . count($large) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function map_2( $__self , $cb ) {
    /* unused:  $__len = count($__self)   **/ ;
    $res = array();
    for ( $i = 0; $i < count($__self); $i++) {
      $it = $__self[$i];
      array_push($res, call_user_func($cb, $it, $i));
    }
    return $res;
  }
  public static function filter_3( $__self , $cb ) {
    $res_1 = array();
    for ( $i_1 = 0; $i_1 < count($__self); $i_1++) {
      $it_1 = $__self[$i_1];
      if ( call_user_func($cb, $it_1, $i_1) ) {
        array_push($res_1, $it_1);
      }
    }
    return $res_1;
  }
}

Scala

main function, Scala

val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
val doubled : collection.mutable.ArrayBuffer[Int] = operatorsOf.map_2(numbers, ((item : Int, index : Int) => item * 2))
val large : collection.mutable.ArrayBuffer[Int] = operatorsOf.filter_3(numbers, ((item : Int, index : Int) => item > 3))
println( "doubled " + doubled.length )
println( "large " + large.length )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 2
object operatorsOf {
  def  map_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int, Int)=> Int) : collection.mutable.ArrayBuffer[Int] = {
    /** unused val __len : Int = __self.length**/
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    for( i <- 0 until __self.length ) {
      val it = __self(i)
      res.append(cb(it, i))
    }
    return res
  }
  def  filter_3( __self : collection.mutable.ArrayBuffer[Int], cb : (Int, Int)=> Boolean) : collection.mutable.ArrayBuffer[Int] = {
    var res_1 : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    for( i_1 <- 0 until __self.length ) {
      val it_1 = __self(i_1)
      if ( cb(it_1, i_1) ) {
        res_1.append(it_1)
      }
    }
    return res_1
  }
}

// application main function for Main
object AppMain extends App {
  val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
  val doubled : collection.mutable.ArrayBuffer[Int] = operatorsOf.map_2(numbers, ((item : Int, index : Int) => item * 2))
  val large : collection.mutable.ArrayBuffer[Int] = operatorsOf.filter_3(numbers, ((item : Int, index : Int) => item > 3))
  println( "doubled " + doubled.length )
  println( "large " + large.length )
}

The Ranger source of the method

fn filter:[T] (cb:(_:boolean (item:T index:int))) {
    def res:[T]
    for self it:T i {
        if( cb(it i) )  {
            push res it
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 733

find

receiver.find(cb) → T

find(cb: (fn:boolean (item:T)))

some useful functions from scala

The compiler writes this method for every target.

The Ranger source of the method

fn find@(optional):T (cb:(_:boolean (item:T))) {
    def res@(optional):T
    for self it@(lives):T i {
        if( cb(it) )  {
            def res2@(optional):T
            res2 = it
            return res2
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 786

forEach

receiver.forEach(cb) → void

forEach(cb: (fn:void (item:T index:int)))

Call `fb` for each item in array

The compiler writes this method for every target.

The Ranger source of the method

fn forEach@(pure):void (cb:(_:void (item:T index:int))) @doc('Call `fb` for each item in array') {
    for self it:T i {
        cb(it i)
    }
}

Definition: lib/stdlib.rgr, line 704

groupBy

receiver.groupBy(cb) → [T]

groupBy(cb: (fn:string (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn groupBy:[T] ( cb:(_:string (item:T)) ) {
    def res:[T]
    def mapper:[string:boolean]
    for self it:T i {
        def key (cb(it))
        if( false == ( has mapper key ) ) {
            push res it
            set mapper key true
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 763

has

receiver.has(el) → boolean

has(el: T)

The compiler writes this method for every target.

The Ranger source of the method

fn has:boolean ( el:T) {
    def idx (indexOf el)
    return (idx >= 0)
}

Definition: lib/stdlib.rgr, line 710

map

receiver.map(cb to) → [S]

map(cb: (fn:S (item:T index:int)), to: [S])

The compiler writes this method for every target.

The Ranger source of the method

fn map:[S] (cb:(_:S (item:T index:int)) to@(noeval):[S] ) {
    def len (array_length self)
    def res:[S]
    for self it:T i {
        push res (cb(it i))
    }
    return res
}

Definition: lib/stdlib.rgr, line 724

map

receiver.map(cb) → [T]

map(cb: (fn:T (item:T index:int)))

The compiler writes this method for every target.

Change and select the items of an array

docs/examples/lib/stdlib/collection-methods.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def numbers:[int] ([] _:int (1 2 3 4 5))
        def doubled (numbers.map({ return (item * 2) }))
        def large (numbers.filter({ return (item > 3) }))
        print ("doubled " + (array_length doubled))
        print ("large " + (array_length large))
    }
}

JavaScript

main function, JavaScript

const numbers = [1, 2, 3, 4, 5];
const doubled = operatorsOf.map_2(numbers, ((item, index) => {
  return item * 2;
}));
const large = operatorsOf.filter_3(numbers, ((item, index) => {
  return item > 3;
}));
console.log("doubled " + doubled.length);
console.log("large " + large.length);

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.map_2 = function(__self, cb) {
  const __len = __self.length;
  let res = [];
  for ( let i = 0; i < __self.length; i++) {
    var it = __self[i];
    res.push(cb(it, i));
  }
  return res;
};
operatorsOf.filter_3 = function(__self, cb) {
  let res_1 = [];
  for ( let i_1 = 0; i_1 < __self.length; i_1++) {
    var it_1 = __self[i_1];
    if ( cb(it_1, i_1) ) {
      res_1.push(it_1);
    }
  }
  return res_1;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers = [1, 2, 3, 4, 5];
  const doubled = operatorsOf.map_2(numbers, ((item, index) => {
    return item * 2;
  }));
  const large = operatorsOf.filter_3(numbers, ((item, index) => {
    return item > 3;
  }));
  console.log("doubled " + doubled.length);
  console.log("large " + large.length);
}
__js_main();

TypeScript

main function, TypeScript

const numbers : Array<number>  = [1, 2, 3, 4, 5];
const doubled : Array<number>  = operatorsOf.map_2(numbers, ((item : number, index : number):number => {
  return item * 2;
}));
const large : Array<number>  = operatorsOf.filter_3(numbers, ((item : number, index : number):boolean => {
  return item > 3;
}));
console.log("doubled " + doubled.length);
console.log("large " + large.length);

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static map_2 (__self : Array<number>, cb : (item:number, index:number) => number) : Array<number>  {
    const __len : number  = __self.length;
    let res : Array<number> | undefined  = [];
    for ( let i = 0; i < __self.length; i++) {
      var it = __self[i];
      res.push(cb(it, i));
    }
    return res;
  };
  static filter_3 (__self : Array<number>, cb : (item:number, index:number) => boolean) : Array<number>  {
    let res_1 : Array<number> | undefined  = [];
    for ( let i_1 = 0; i_1 < __self.length; i_1++) {
      var it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.push(it_1);
      }
    }
    return res_1;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers : Array<number>  = [1, 2, 3, 4, 5];
  const doubled : Array<number>  = operatorsOf.map_2(numbers, ((item : number, index : number):number => {
    return item * 2;
  }));
  const large : Array<number>  = operatorsOf.filter_3(numbers, ((item : number, index : number):boolean => {
    return item > 3;
  }));
  console.log("doubled " + doubled.length);
  console.log("large " + large.length);
}
__js_main();

Go

main function, Go

var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
var doubled []int64= operatorsOf_static_map_2(numbers, func (item int64, index int64) int64 {
  return item * int64(2)
});
var large []int64= operatorsOf_static_filter_3(numbers, func (item int64, index int64) bool {
  return item > int64(3)
});
fmt.Println( strings.Join([]string{ "doubled ",strconv.FormatInt(int64(len(doubled)), 10) }, "") )
fmt.Println( strings.Join([]string{ "large ",strconv.FormatInt(int64(len(large)), 10) }, "") )

The complete file

package main
import (
  "strings"
  "strconv"
  "fmt"
)
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
  var doubled []int64= operatorsOf_static_map_2(numbers, func (item int64, index int64) int64 {
    return item * int64(2)
  });
  var large []int64= operatorsOf_static_filter_3(numbers, func (item int64, index int64) bool {
    return item > int64(3)
  });
  fmt.Println( strings.Join([]string{ "doubled ",strconv.FormatInt(int64(len(doubled)), 10) }, "") )
  fmt.Println( strings.Join([]string{ "large ",strconv.FormatInt(int64(len(large)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_map_2(__self []int64, cb func(int64, int64) int64) []int64 {
  /* unused:  __len*/
  var res []int64 = make([]int64, 0);
  var i int64 = 0;
  for ; i < int64(len(__self)) ; i++ {
    it := __self[i]
    res = append(res,cb(it, i));
  }
  return res
}
func operatorsOf_static_filter_3(__self []int64, cb func(int64, int64) bool) []int64 {
  var res_1 []int64 = make([]int64, 0);
  var i_1 int64 = 0;
  for ; i_1 < int64(len(__self)) ; i_1++ {
    it_1 := __self[i_1]
    if  cb(it_1, i_1) {
      res_1 = append(res_1,it_1);
    }
  }
  return res_1
}

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)]
#![allow(unused_mut)]

#[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![1, 2, 3, 4, 5];
  let mut doubled: Vec<i64> = operatorsOf::map_2(&numbers, &mut |mut item, mut index| {
    return item * 2;
  });
  let mut large: Vec<i64> = operatorsOf::filter_3(&numbers, &mut |mut item, mut index| {
    return item > 3;
  });
  println!("doubled {}", doubled.len() as i64);
  println!("large {}", large.len() as i64);
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn map_2(__self: &[i64], cb: &mut dyn FnMut(i64, i64) -> i64) -> Vec<i64> {
    // unused:  let __len: i64 = __self.len() as i64;
    let mut res: Vec<i64> = Vec::new();
    let __n_i = __self.len() as i64;
    for i in 0..__n_i {
      let mut it = __self[i as usize];
      res.push(cb(it, i.clone()));
    }
    res.clone()
  }
  pub fn filter_3(__self: &[i64], cb: &mut dyn FnMut(i64, i64) -> bool) -> Vec<i64> {
    let mut res_1: Vec<i64> = Vec::new();
    let __n_i = __self.len() as i64;
    for i_1 in 0..__n_i {
      let mut it_1 = __self[i_1 as usize];
      if  cb(it_1, i_1.clone()) {
        res_1.push(it_1);
      }
    }
    res_1.clone()
  }
}

Python

main function, Python

def __rg_lambda_1(item, index):
  return item * 2;
def __rg_lambda_2(item, index):
  return item > 3;
numbers = [1, 2, 3, 4, 5]
doubled = operatorsOf.map_2(numbers, __rg_lambda_1)
large = operatorsOf.filter_3(numbers, __rg_lambda_2)
print("doubled " + str(len(doubled)))
print("large " + str(len(large)))

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():
  def __rg_lambda_1(item, index):
    return item * 2;
  def __rg_lambda_2(item, index):
    return item > 3;
  numbers = [1, 2, 3, 4, 5]
  doubled = operatorsOf.map_2(numbers, __rg_lambda_1)
  large = operatorsOf.filter_3(numbers, __rg_lambda_2)
  print("doubled " + str(len(doubled)))
  print("large " + str(len(large)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def map_2(__self: list[int], cb) -> list[int]:
    pass  # unused:  __len = len(__self)
    res = []
    for i, it in enumerate(__self):
      res.append(cb(it, i))
    return res;
  @staticmethod
  def filter_3(__self: list[int], cb) -> list[int]:
    res_1 = []
    for i_1, it_1 in enumerate(__self):
      if cb(it_1, i_1):
        res_1.append(it_1)
    return res_1;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
final ArrayList<Integer> doubled = operatorsOf.map_2(numbers, new LambdaSignature1() {
  public Integer run( final Integer item,  final Integer index) {
    return item * 2;
  }
});
final ArrayList<Integer> large = operatorsOf.filter_3(numbers, new LambdaSignature2() {
  public Boolean run( final Integer item,  final Integer index) {
    return item > 3;
  }
});
System.out.println(String.valueOf( "doubled " + doubled.size() ) );
System.out.println(String.valueOf( "large " + large.size() ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
    final ArrayList<Integer> doubled = operatorsOf.map_2(numbers, new LambdaSignature1() {
      public Integer run( final Integer item,  final Integer index) {
        return item * 2;
      }
    });
    final ArrayList<Integer> large = operatorsOf.filter_3(numbers, new LambdaSignature2() {
      public Boolean run( final Integer item,  final Integer index) {
        return item > 3;
      }
    });
    System.out.println(String.valueOf( "doubled " + doubled.size() ) );
    System.out.println(String.valueOf( "large " + large.size() ) );
  }
}


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


public interface LambdaSignature1 {
  public Integer run( final Integer item,  final Integer index);
}


public interface LambdaSignature2 {
  public Boolean run( final Integer item,  final Integer index);
}


import java.util.*;

public class operatorsOf {

  public static ArrayList<Integer> map_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    /* unused:  final Integer __len = __self.size()   **/ ;
    ArrayList<Integer> res = new ArrayList<Integer>();
    for ( int i = 0; i < __self.size(); i++) {
      Integer it = __self.get(i);
      res.add(cb.run(it, i));
    }
    return res;
  }

  public static ArrayList<Integer> filter_3( final ArrayList<Integer> __self , final LambdaSignature2 cb ) {
    ArrayList<Integer> res_1 = new ArrayList<Integer>();
    for ( int i_1 = 0; i_1 < __self.size(); i_1++) {
      Integer it_1 = __self.get(i_1);
      if ( cb.run(it_1, i_1) ) {
        res_1.add(it_1);
      }
    }
    return res_1;
  }
}

Kotlin

main function, Kotlin

__g_args = args
val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
val doubled : MutableList<Int>  = operatorsOf.map_2(numbers, fun(item : Int, index : Int) : Int {
  return item * 2;
});
val large : MutableList<Int>  = operatorsOf.filter_3(numbers, fun(item : Int, index : Int) : Boolean {
  return item > 3;
});
println( "doubled " + (doubled.size).toString() )
println( "large " + (large.size).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
  val doubled : MutableList<Int>  = operatorsOf.map_2(numbers, fun(item : Int, index : Int) : Int {
    return item * 2;
  });
  val large : MutableList<Int>  = operatorsOf.filter_3(numbers, fun(item : Int, index : Int) : Boolean {
    return item > 3;
  });
  println( "doubled " + (doubled.size).toString() )
  println( "large " + (large.size).toString() )
}

class operatorsOf
 {
  companion object {

    fun  map_2( __self : MutableList<Int>, cb : (Int, Int) -> Int) : MutableList<Int> {
      /* unused:  val __len : Int  = __self.size   **/ ;
      var res : MutableList<Int>  = arrayListOf();
      for ( i in __self.indices ) {
        val it = __self[i]
        res.add(cb(it, i));
      }
      return res;
    }

    fun  filter_3( __self : MutableList<Int>, cb : (Int, Int) -> Boolean) : MutableList<Int> {
      var res_1 : MutableList<Int>  = arrayListOf();
      for ( i_1 in __self.indices ) {
        val it_1 = __self[i_1]
        if ( cb(it_1, i_1) ) {
          res_1.add(it_1);
        }
      }
      return res_1;
    }
  }
}

Dart

main function, Dart

__g_args = args;
List<int> numbers = [1, 2, 3, 4, 5];
List<int> doubled = operatorsOf.map_2(numbers, (item, index) {
  return item * 2;
}
);
List<int> large = operatorsOf.filter_3(numbers, (item, index) {
  return item > 3;
}
);
print( "doubled " + (doubled.length).toString() );
print( "large " + (large.length).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [1, 2, 3, 4, 5];
  List<int> doubled = operatorsOf.map_2(numbers, (item, index) {
    return item * 2;
  }
  );
  List<int> large = operatorsOf.filter_3(numbers, (item, index) {
    return item > 3;
  }
  );
  print( "doubled " + (doubled.length).toString() );
  print( "large " + (large.length).toString() );
}

class operatorsOf {

  static List<int> map_2(List<int> __self, int Function(int, int) cb) {
    /* unused:  int __len = __self.length   */
    List<int> res = [];
    for ( int i = 0; i < __self.length; i++) {
      var it = __self[i];
      res.add(cb(it, i));
    }
    return res;
  }

  static List<int> filter_3(List<int> __self, bool Function(int, int) cb) {
    List<int> res_1 = [];
    for ( int i_1 = 0; i_1 < __self.length; i_1++) {
      var it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.add(it_1);
      }
    }
    return res_1;
  }
}

Swift

main function, Swift

let numbers : [Int] = [1, 2, 3, 4, 5]
let doubled : [Int] = operatorsOf.map_2(__self : numbers, cb : ({ (item, index) ->  Int in
  return item * 2
}))
let large : [Int] = operatorsOf.filter_3(__self : numbers, cb : ({ (item, index) ->  Bool in
  return item > 3
}))
print("doubled " + String(doubled.count))
print("large " + String(large.count))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func map_2(__self : [Int], cb :   @escaping  (( _ : Int,  _ : Int) -> Int)) -> [Int] {
    /* unused:  let __len : Int = __self.count   **/
    var res : [Int] = [Int]()
    for (i, it) in __self.enumerated() {
      res.append(cb(it, i))
    }
    return res
  }
  class func filter_3(__self : [Int], cb :   @escaping  (( _ : Int,  _ : Int) -> Bool)) -> [Int] {
    var res_1 : [Int] = [Int]()
    for (i_1, it_1) in __self.enumerated() {
      if ( cb(it_1, i_1) ) {
        res_1.append(it_1)
      }
    }
    return res_1
  }
}
// Main entry point
func __main__swift() {
  let numbers : [Int] = [1, 2, 3, 4, 5]
  let doubled : [Int] = operatorsOf.map_2(__self : numbers, cb : ({ (item, index) ->  Int in
    return item * 2
  }))
  let large : [Int] = operatorsOf.filter_3(__self : numbers, cb : ({ (item, index) ->  Bool in
    return item > 3
  }))
  print("doubled " + String(doubled.count))
  print("large " + String(large.count))
}
__main__swift()

C#

main function, C#

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
List<int> doubled = operatorsOf.map_2(numbers, ((Func<int, int, int>)((item, index) => {
  return item * 2;
})));
List<int> large = operatorsOf.filter_3(numbers, ((Func<int, int, bool>)((item, index) => {
  return item > 3;
})));
Console.WriteLine("doubled " + doubled.Count);
Console.WriteLine("large " + large.Count);

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> {1, 2, 3, 4, 5};
    List<int> doubled = operatorsOf.map_2(numbers, ((Func<int, int, int>)((item, index) => {
      return item * 2;
    })));
    List<int> large = operatorsOf.filter_3(numbers, ((Func<int, int, bool>)((item, index) => {
      return item > 3;
    })));
    Console.WriteLine("doubled " + doubled.Count);
    Console.WriteLine("large " + large.Count);
  }
}
class operatorsOf  {
  public static List<int> map_2( List<int> __self , Func<int, int, int> cb ) {
    /* unused:  int __len = __self.Count   **/ ;
    List<int> res = new List<int>();
    for ( int i = 0; i < __self.Count; i++) {
      int it = __self[i];
      res.Add(cb(it, i));
    }
    return res;
  }
  public static List<int> filter_3( List<int> __self , Func<int, int, bool> cb ) {
    List<int> res_1 = new List<int>();
    for ( int i_1 = 0; i_1 < __self.Count; i_1++) {
      int it_1 = __self[i_1];
      if ( cb(it_1, i_1) ) {
        res_1.Add(it_1);
      }
    }
    return res_1;
  }
}

C++

main function, C++

std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
std::vector<int> doubled = operatorsOf::map_2(numbers, [&](int item, int index) mutable {
  return item * 2;
});
std::vector<int> large = operatorsOf::filter_3(numbers, [&](int item, int index) mutable {
  return item > 3;
});
std::cout << std::string("doubled ") + std::to_string((int)(doubled.size())) << std::endl;
std::cout << std::string("large ") + std::to_string((int)(large.size())) << std::endl;
return 0;

The complete file

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

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



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static std::vector<int> map_2( const std::vector<int>& __self , std::function<int(int, int)> cb );
    static std::vector<int> filter_3( const std::vector<int>& __self , std::function<bool(int, int)> cb );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
  std::vector<int> doubled = operatorsOf::map_2(numbers, [&](int item, int index) mutable {
    return item * 2;
  });
  std::vector<int> large = operatorsOf::filter_3(numbers, [&](int item, int index) mutable {
    return item > 3;
  });
  std::cout << std::string("doubled ") + std::to_string((int)(doubled.size())) << std::endl;
  std::cout << std::string("large ") + std::to_string((int)(large.size())) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
std::vector<int>  operatorsOf::map_2( const std::vector<int>& __self , std::function<int(int, int)> cb ) {
  /* unused:  int __len = (int)(__self.size())   **/ ;
  std::vector<int> res;
  for ( int i = 0; i != (int)(__self.size()); i++) {
    int it = __self.at(i);
    res.push_back( cb(it, i)  );
  }
  return res;
}
std::vector<int>  operatorsOf::filter_3( const std::vector<int>& __self , std::function<bool(int, int)> cb ) {
  std::vector<int> res_1;
  for ( int i_1 = 0; i_1 != (int)(__self.size()); i_1++) {
    int it_1 = __self.at(i_1);
    if ( cb(it_1, i_1) ) {
      res_1.push_back( it_1  );
    }
  }
  return res_1;
}

PHP

main function, PHP

$numbers = array(1, 2, 3, 4, 5);
$doubled = operatorsOf::map_2($numbers, (function ($item, $index)  {
  return $item * 2;
}));
$large = operatorsOf::filter_3($numbers, (function ($item, $index)  {
  return $item > 3;
}));
echo( "doubled " . count($doubled) . "\n");
echo( "large " . count($large) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function map_2( $__self , $cb ) {
    /* unused:  $__len = count($__self)   **/ ;
    $res = array();
    for ( $i = 0; $i < count($__self); $i++) {
      $it = $__self[$i];
      array_push($res, call_user_func($cb, $it, $i));
    }
    return $res;
  }
  public static function filter_3( $__self , $cb ) {
    $res_1 = array();
    for ( $i_1 = 0; $i_1 < count($__self); $i_1++) {
      $it_1 = $__self[$i_1];
      if ( call_user_func($cb, $it_1, $i_1) ) {
        array_push($res_1, $it_1);
      }
    }
    return $res_1;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array(1, 2, 3, 4, 5);
$doubled = operatorsOf::map_2($numbers, (function ($item, $index)  {
  return $item * 2;
}));
$large = operatorsOf::filter_3($numbers, (function ($item, $index)  {
  return $item > 3;
}));
echo( "doubled " . count($doubled) . "\n");
echo( "large " . count($large) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function map_2( $__self , $cb ) {
    /* unused:  $__len = count($__self)   **/ ;
    $res = array();
    for ( $i = 0; $i < count($__self); $i++) {
      $it = $__self[$i];
      array_push($res, call_user_func($cb, $it, $i));
    }
    return $res;
  }
  public static function filter_3( $__self , $cb ) {
    $res_1 = array();
    for ( $i_1 = 0; $i_1 < count($__self); $i_1++) {
      $it_1 = $__self[$i_1];
      if ( call_user_func($cb, $it_1, $i_1) ) {
        array_push($res_1, $it_1);
      }
    }
    return $res_1;
  }
}

Scala

main function, Scala

val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
val doubled : collection.mutable.ArrayBuffer[Int] = operatorsOf.map_2(numbers, ((item : Int, index : Int) => item * 2))
val large : collection.mutable.ArrayBuffer[Int] = operatorsOf.filter_3(numbers, ((item : Int, index : Int) => item > 3))
println( "doubled " + doubled.length )
println( "large " + large.length )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 2
object operatorsOf {
  def  map_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int, Int)=> Int) : collection.mutable.ArrayBuffer[Int] = {
    /** unused val __len : Int = __self.length**/
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    for( i <- 0 until __self.length ) {
      val it = __self(i)
      res.append(cb(it, i))
    }
    return res
  }
  def  filter_3( __self : collection.mutable.ArrayBuffer[Int], cb : (Int, Int)=> Boolean) : collection.mutable.ArrayBuffer[Int] = {
    var res_1 : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    for( i_1 <- 0 until __self.length ) {
      val it_1 = __self(i_1)
      if ( cb(it_1, i_1) ) {
        res_1.append(it_1)
      }
    }
    return res_1
  }
}

// application main function for Main
object AppMain extends App {
  val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
  val doubled : collection.mutable.ArrayBuffer[Int] = operatorsOf.map_2(numbers, ((item : Int, index : Int) => item * 2))
  val large : collection.mutable.ArrayBuffer[Int] = operatorsOf.filter_3(numbers, ((item : Int, index : Int) => item > 3))
  println( "doubled " + doubled.length )
  println( "large " + large.length )
}

The Ranger source of the method

fn map:[T] (cb:(_:T (item:T index:int))) {
    def len (array_length self)
    def res:[T]
    for self it:T i {
        push res (cb(it i))
    }
    return res
}

Definition: lib/stdlib.rgr, line 715

reduce

receiver.reduce(cb initialValue) → K

reduce(cb: (fn:K (left:K right:T index:int)), initialValue: K)

The compiler writes this method for every target.

The Ranger source of the method

fn reduce@(weak):K (cb:(_:K (left:K right:T index:int)) initialValue:K) {
    def len (array_length self)
    def res initialValue
    if( len >= 1 ) {
        for self it:T i {
            res = ( cb ( res it i ))
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 752

reduce

receiver.reduce(cb initialValue) → T

reduce(cb: (fn:T (left:T right:T index:int)), initialValue: T)

The compiler writes this method for every target.

The Ranger source of the method

fn reduce@(weak):T (cb:(_:T (left:T right:T index:int)) initialValue:T) {
    def len (array_length self)
    def res:T initialValue
    if( len >= 1 ) {
        for self it:T i {
            res = ( cb ( res it i))
        }
    }
    return res
}

Definition: lib/stdlib.rgr, line 742

slice

receiver.slice(start end) → [T]

slice(start: int, end: int)

Items from `start` up to but not including `end`

The compiler writes this method for every target.

Test the items of an array and take a part of it

docs/examples/lib/stdlib/tests-and-slice.rgr

Import "stdlib.rgr"

class Main {
    sfn main:void () {
        def numbers:[int] ([] _:int (1 2 3 4 5))
        if (numbers.any({ return (item > 4) })) {
            print "one item is greater than four"
        }
        if (numbers.all({ return (item > 0) })) {
            print "every item is positive"
        }
        def part (numbers.slice(1 3))
        print ("part " + (array_length part))
    }
}

JavaScript

main function, JavaScript

const numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item) => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item) => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
}
operatorsOf.any_2 = function(__self, cb) {
  for ( const it of __self) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
};
operatorsOf.all_2 = function(__self, cb) {
  for ( const it_1 of __self) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
};
operatorsOf.slice_3 = function(__self, start, end) {
  let res = [];
  const __len = __self.length;
  let from = start;
  let to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  let i_2 = from;
  while (i_2 < to) {
    res.push(__self[i_2]);
    i_2 = i_2 + 1;
  };
  return res;
};
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item) => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item) => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

TypeScript

main function, TypeScript

const numbers : Array<number>  = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
  return item > 4;
})) ) {
  console.log("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
  return item > 0;
})) ) {
  console.log("every item is positive");
}
const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
console.log("part " + part.length);

The complete file

export class Main  {
  constructor() {
  }
}
class operatorsOf  {
  constructor() {
  }
  static any_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it of __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  };
  static all_2 (__self : Array<number>, cb : (item:number) => boolean) : boolean  {
    for ( const it_1 of __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  };
  static slice_3 (__self : Array<number>, start : number, end : number) : Array<number>  {
    let res : Array<number> | undefined  = [];
    const __len : number  = __self.length;
    let from : number  = start;
    let to : number  = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    let i_2 : number  = from;
    while (i_2 < to) {
      res.push(__self[i_2]);
      i_2 = i_2 + 1;
    };
    return res;
  };
}
/* static JavaSript main routine at the end of the JS file */
function __js_main() {
  const numbers : Array<number>  = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, ((item : number):boolean => {
    return item > 4;
  })) ) {
    console.log("one item is greater than four");
  }
  if ( operatorsOf.all_2(numbers, ((item : number):boolean => {
    return item > 0;
  })) ) {
    console.log("every item is positive");
  }
  const part : Array<number>  = operatorsOf.slice_3(numbers, 1, 3);
  console.log("part " + part.length);
}
__js_main();

Go

main function, Go

var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
if  operatorsOf_static_any_2(numbers, func (item int64) bool {
  return item > int64(4)
}) {
  fmt.Println( "one item is greater than four" )
}
if  operatorsOf_static_all_2(numbers, func (item int64) bool {
  return item > int64(0)
}) {
  fmt.Println( "every item is positive" )
}
var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )

The complete file

package main
import (
  "fmt"
  "strings"
  "strconv"
)
type Main struct {
}

func CreateNew_Main() *Main {
  me := new(Main)
  return me;
}
func main() {
  var numbers []int64= []int64 {int64(1), int64(2), int64(3), int64(4), int64(5)};
  if  operatorsOf_static_any_2(numbers, func (item int64) bool {
    return item > int64(4)
  }) {
    fmt.Println( "one item is greater than four" )
  }
  if  operatorsOf_static_all_2(numbers, func (item int64) bool {
    return item > int64(0)
  }) {
    fmt.Println( "every item is positive" )
  }
  var part []int64= operatorsOf_static_slice_3(numbers, int64(1), int64(3));
  fmt.Println( strings.Join([]string{ "part ",strconv.FormatInt(int64(len(part)), 10) }, "") )
}
type operatorsOf struct {
}

func CreateNew_operatorsOf() *operatorsOf {
  me := new(operatorsOf)
  return me;
}
func operatorsOf_static_any_2(__self []int64, cb func(int64) bool) bool {
  for _, it := range __self {
    if  cb(it) {
      return true
    }
  }
  return false
}
func operatorsOf_static_all_2(__self []int64, cb func(int64) bool) bool {
  for _, it_1 := range __self {
    if  cb(it_1) == false {
      return false
    }
  }
  return true
}
func operatorsOf_static_slice_3(__self []int64, start int64, end int64) []int64 {
  var res []int64 = make([]int64, 0);
  var __len int64= int64(len(__self));
  var from int64= start;
  var to int64= end;
  if  from < int64(0) {
    from = int64(0);
  }
  if  to > __len {
    to = __len;
  }
  var i_2 int64= from;
  for i_2 < to {
    res = append(res,__self[i_2]);
    i_2 = i_2 + int64(1);
  }
  return res
}

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)]
#![allow(unused_mut)]

#[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![1, 2, 3, 4, 5];
  if  operatorsOf::any_2(&numbers, &mut |mut item| {
    return item > 4;
  }) {
    println!("one item is greater than four");
  }
  if  operatorsOf::all_2(&numbers, &mut |mut item| {
    return item > 0;
  }) {
    println!("every item is positive");
  }
  let mut part: Vec<i64> = operatorsOf::slice_3(&numbers, 1, 3);
  println!("part {}", part.len() as i64);
}
#[derive(Clone)]
struct operatorsOf {
}
impl operatorsOf {
  pub fn new() -> Self {
    Self {
    }
  }
  pub fn any_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it in __self.iter().copied() {
      if  cb(it) {
        return true;
      }
    }
    false
  }
  pub fn all_2(__self: &[i64], cb: &mut dyn FnMut(i64) -> bool) -> bool {
    for it_1 in __self.iter().copied() {
      if  !(cb(it_1)) {
        return false;
      }
    }
    true
  }
  pub fn slice_3(__self: &[i64], start: i64, end: i64) -> Vec<i64> {
    let mut res: Vec<i64> = Vec::new();
    let __len: i64 = __self.len() as i64;
    let mut from: i64 = start;
    let mut to: i64 = end;
    if  from < 0 {
      from = 0;
    }
    if  to > __len {
      to = __len;
    }
    let mut i_2: i64 = from;
    while i_2 < to {
      res.push(__self[(i_2) as usize]);
      i_2 += 1;
    };
    res.clone()
  }
}

Python

main function, Python

def __rg_lambda_1(item):
  return item > 4;
def __rg_lambda_2(item):
  return item > 0;
numbers = [1, 2, 3, 4, 5]
if operatorsOf.any_2(numbers, __rg_lambda_1):
  print("one item is greater than four")
if operatorsOf.all_2(numbers, __rg_lambda_2):
  print("every item is positive")
part = operatorsOf.slice_3(numbers, 1, 3)
print("part " + str(len(part)))

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():
  def __rg_lambda_1(item):
    return item > 4;
  def __rg_lambda_2(item):
    return item > 0;
  numbers = [1, 2, 3, 4, 5]
  if operatorsOf.any_2(numbers, __rg_lambda_1):
    print("one item is greater than four")
  if operatorsOf.all_2(numbers, __rg_lambda_2):
    print("every item is positive")
  part = operatorsOf.slice_3(numbers, 1, 3)
  print("part " + str(len(part)))
class operatorsOf:
  def __init__(self) -> None:
    pass
  @staticmethod
  def any_2(__self: list[int], cb) -> bool:
    for it in __self:
      if cb(it):
        return True;
    return False;
  @staticmethod
  def all_2(__self: list[int], cb) -> bool:
    for it_1 in __self:
      if cb(it_1) == False:
        return False;
    return True;
  @staticmethod
  def slice_3(__self: list[int], start: int, end: int) -> list[int]:
    res = []
    __len = len(__self)
    _from = start
    to = end
    if _from < 0:
      _from = 0;
    if to > __len:
      to = __len;
    i_2 = _from
    while i_2 < to:
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    return res;
if __name__ == "__main__":
  main()

Java

main function, Java

RgArgs.args = args;
final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 4;
  }
}) ) {
  System.out.println(String.valueOf( "one item is greater than four" ) );
}
if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
  public Boolean run( final Integer item) {
    return item > 0;
  }
}) ) {
  System.out.println(String.valueOf( "every item is positive" ) );
}
final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
System.out.println(String.valueOf( "part " + part.size() ) );

The complete file

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

public class Main {

  public static void main(String [] args ) {
    RgArgs.args = args;
    final ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList( new Integer[] {1, 2, 3, 4, 5}));
    if ( operatorsOf.any_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 4;
      }
    }) ) {
      System.out.println(String.valueOf( "one item is greater than four" ) );
    }
    if ( operatorsOf.all_2(numbers, new LambdaSignature1() {
      public Boolean run( final Integer item) {
        return item > 0;
      }
    }) ) {
      System.out.println(String.valueOf( "every item is positive" ) );
    }
    final ArrayList<Integer> part = operatorsOf.slice_3(numbers, 1, 3);
    System.out.println(String.valueOf( "part " + part.size() ) );
  }
}


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


public interface LambdaSignature1 {
  public Boolean run( final Integer item);
}


import java.util.*;

public class operatorsOf {

  public static Boolean any_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it : __self) {
      if ( cb.run(it) ) {
        return true;
      }
    }
    return false;
  }

  public static Boolean all_2( final ArrayList<Integer> __self , final LambdaSignature1 cb ) {
    for ( Integer it_1 : __self) {
      if ( cb.run(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  public static ArrayList<Integer> slice_3( final ArrayList<Integer> __self , final Integer start , final Integer end ) {
    ArrayList<Integer> res = new ArrayList<Integer>();
    final Integer __len = __self.size();
    Integer from = start;
    Integer to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    Integer i_2 = from;
    while (i_2 < to) {
      res.add(__self.get(i_2));
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Kotlin

main function, Kotlin

__g_args = args
val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
  return item > 4;
}) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
  return item > 0;
}) ) {
  println( "every item is positive" )
}
val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
println( "part " + (part.size).toString() )

The complete file

class Main
 {

}

var __g_args : Array<String> = arrayOf()

fun main(args : Array<String>) {
  __g_args = args
  val numbers : MutableList<Int>  = arrayListOf<Int>(1, 2, 3, 4, 5);
  if ( operatorsOf.any_2(numbers, fun(item : Int) : Boolean {
    return item > 4;
  }) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, fun(item : Int) : Boolean {
    return item > 0;
  }) ) {
    println( "every item is positive" )
  }
  val part : MutableList<Int>  = operatorsOf.slice_3(numbers, 1, 3);
  println( "part " + (part.size).toString() )
}

class operatorsOf
 {
  companion object {

    fun  any_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it in __self ) {
        if ( cb(it) ) {
          return true;
        }
      }
      return false;
    }

    fun  all_2( __self : MutableList<Int>, cb : (Int) -> Boolean) : Boolean {
      for ( it_1 in __self ) {
        if ( cb(it_1) == false ) {
          return false;
        }
      }
      return true;
    }

    fun  slice_3( __self : MutableList<Int>, start : Int, end : Int) : MutableList<Int> {
      var res : MutableList<Int>  = arrayListOf();
      val __len : Int  = __self.size;
      var from : Int  = start;
      var to : Int  = end;
      if ( from < 0 ) {
        from = 0;
      }
      if ( to > __len ) {
        to = __len;
      }
      var i_2 : Int  = from;
      while (i_2 < to) {
        res.add(__self[i_2]);
        i_2 = i_2 + 1;
      }
      return res;
    }
  }
}

Dart

main function, Dart

__g_args = args;
List<int> numbers = [1, 2, 3, 4, 5];
if ( operatorsOf.any_2(numbers, (item) {
  return item > 4;
}
) ) {
  print( "one item is greater than four" );
}
if ( operatorsOf.all_2(numbers, (item) {
  return item > 0;
}
) ) {
  print( "every item is positive" );
}
List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
print( "part " + (_part.length).toString() );

The complete file

class Main {
}

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

void main(List<String> args) {
  __g_args = args;
  List<int> numbers = [1, 2, 3, 4, 5];
  if ( operatorsOf.any_2(numbers, (item) {
    return item > 4;
  }
  ) ) {
    print( "one item is greater than four" );
  }
  if ( operatorsOf.all_2(numbers, (item) {
    return item > 0;
  }
  ) ) {
    print( "every item is positive" );
  }
  List<int> _part = operatorsOf.slice_3(numbers, 1, 3);
  print( "part " + (_part.length).toString() );
}

class operatorsOf {

  static bool any_2(List<int> __self, bool Function(int) cb) {
    for ( final it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }

  static bool all_2(List<int> __self, bool Function(int) cb) {
    for ( final it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }

  static List<int> slice_3(List<int> __self, int start, int end) {
    List<int> res = [];
    int __len = __self.length;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

Swift

main function, Swift

let numbers : [Int] = [1, 2, 3, 4, 5]
if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 4
})) ) {
  print("one item is greater than four")
}
if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
  return item > 0
})) ) {
  print("every item is positive")
}
let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
print("part " + String(part.count))

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))
  }
}
func ==(l: operatorsOf, r: operatorsOf) -> Bool {
  return l === r
}
final class operatorsOf : Hashable  {
  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(self))
  }
  class func any_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it in __self {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  class func all_2(__self : [Int], cb :   @escaping  (( _ : Int) -> Bool)) -> Bool {
    for it_1 in __self {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  class func slice_3(__self : [Int], start : Int, end : Int) -> [Int] {
    var res : [Int] = [Int]()
    let __len : Int = __self.count
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    var i_2 : Int = from
    while (i_2 < to) {
      res.append(__self[i_2])
      i_2 = i_2 + 1;
    }
    return res
  }
}
// Main entry point
func __main__swift() {
  let numbers : [Int] = [1, 2, 3, 4, 5]
  if ( operatorsOf.any_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 4
  })) ) {
    print("one item is greater than four")
  }
  if ( operatorsOf.all_2(__self : numbers, cb : ({ (item) ->  Bool in
    return item > 0
  })) ) {
    print("every item is positive")
  }
  let part : [Int] = operatorsOf.slice_3(__self : numbers, start : 1, end : 3)
  print("part " + String(part.count))
}
__main__swift()

C#

main function, C#

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
  return item > 4;
}))) ) {
  Console.WriteLine("one item is greater than four");
}
if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
  return item > 0;
}))) ) {
  Console.WriteLine("every item is positive");
}
List<int> part = operatorsOf.slice_3(numbers, 1, 3);
Console.WriteLine("part " + part.Count);

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> {1, 2, 3, 4, 5};
    if ( operatorsOf.any_2(numbers, ((Func<int, bool>)((item) => {
      return item > 4;
    }))) ) {
      Console.WriteLine("one item is greater than four");
    }
    if ( operatorsOf.all_2(numbers, ((Func<int, bool>)((item) => {
      return item > 0;
    }))) ) {
      Console.WriteLine("every item is positive");
    }
    List<int> part = operatorsOf.slice_3(numbers, 1, 3);
    Console.WriteLine("part " + part.Count);
  }
}
class operatorsOf  {
  public static bool any_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it in __self) {
      if ( cb(it) ) {
        return true;
      }
    }
    return false;
  }
  public static bool all_2( List<int> __self , Func<int, bool> cb ) {
    foreach ( int it_1 in __self) {
      if ( cb(it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static List<int> slice_3( List<int> __self , int start , int end ) {
    List<int> res = new List<int>();
    int __len = __self.Count;
    int from = start;
    int to = end;
    if ( from < 0 ) {
      from = 0;
    }
    if ( to > __len ) {
      to = __len;
    }
    int i_2 = from;
    while (i_2 < to) {
      res.Add(__self[i_2]);
      i_2 = i_2 + 1;
    }
    return res;
  }
}

C++

main function, C++

std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
if ( operatorsOf::any_2(numbers, [&](int item) mutable {
  return item > 4;
}) ) {
  std::cout << std::string("one item is greater than four") << std::endl;
}
if ( operatorsOf::all_2(numbers, [&](int item) mutable {
  return item > 0;
}) ) {
  std::cout << std::string("every item is positive") << std::endl;
}
std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
return 0;

The complete file

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

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



// header definitions
class Main {
  public :
    /* class constructor */
    Main( );
    /* static methods */
    static void main();
};
class operatorsOf {
  public :
    /* class constructor */
    operatorsOf( );
    /* static methods */
    static bool any_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static bool all_2( const std::vector<int>& __self , std::function<bool(int)> cb );
    static std::vector<int> slice_3( const std::vector<int>& __self , int start , int end );
};

int __g_argc;
char **__g_argv;
Main::Main( ) {
}
int main(int argc, char* argv[]) {
  __g_argc = argc;
  __g_argv = argv;
  std::vector<int> numbers = std::vector<int>{1, 2, 3, 4, 5};
  if ( operatorsOf::any_2(numbers, [&](int item) mutable {
    return item > 4;
  }) ) {
    std::cout << std::string("one item is greater than four") << std::endl;
  }
  if ( operatorsOf::all_2(numbers, [&](int item) mutable {
    return item > 0;
  }) ) {
    std::cout << std::string("every item is positive") << std::endl;
  }
  std::vector<int> part = operatorsOf::slice_3(numbers, 1, 3);
  std::cout << std::string("part ") + std::to_string((int)(part.size())) << std::endl;
  return 0;
}
operatorsOf::operatorsOf( ) {
}
bool  operatorsOf::any_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it : __self ) {
    if ( cb(it) ) {
      return true;
    }
  }
  return false;
}
bool  operatorsOf::all_2( const std::vector<int>& __self , std::function<bool(int)> cb ) {
  for ( int it_1 : __self ) {
    if ( cb(it_1) == false ) {
      return false;
    }
  }
  return true;
}
std::vector<int>  operatorsOf::slice_3( const std::vector<int>& __self , int start , int end ) {
  std::vector<int> res;
  int __len = (int)(__self.size());
  int from = start;
  int to = end;
  if ( from < 0 ) {
    from = 0;
  }
  if ( to > __len ) {
    to = __len;
  }
  int i_2 = from;
  while (i_2 < to) {
    res.push_back( __self.at(i_2)  );
    i_2 = i_2 + 1;
  };
  return res;
}

PHP

main function, PHP

$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

The complete file

<?php

class Main {
  function __construct( ) {
  }
}
/* static PHP main routine */
$numbers = array(1, 2, 3, 4, 5);
if ( operatorsOf::any_2($numbers, (function ($item)  {
  return $item > 4;
})) ) {
  echo( "one item is greater than four" . "\n");
}
if ( operatorsOf::all_2($numbers, (function ($item)  {
  return $item > 0;
})) ) {
  echo( "every item is positive" . "\n");
}
$part = operatorsOf::slice_3($numbers, 1, 3);
echo( "part " . count($part) . "\n");
class operatorsOf {
  function __construct( ) {
  }
  public static function any_2( $__self , $cb ) {
    foreach ( $__self as $it ) {
      if ( call_user_func($cb, $it) ) {
        return true;
      }
    }
    return false;
  }
  public static function all_2( $__self , $cb ) {
    foreach ( $__self as $it_1 ) {
      if ( call_user_func($cb, $it_1) == false ) {
        return false;
      }
    }
    return true;
  }
  public static function slice_3( $__self , $start , $end ) {
    $res = array();
    $__len = count($__self);
    $from = $start;
    $to = $end;
    if ( $from < 0 ) {
      $from = 0;
    }
    if ( $to > $__len ) {
      $to = $__len;
    }
    $i_2 = $from;
    while ($i_2 < $to) {
      array_push($res, $__self[$i_2]);
      $i_2 = $i_2 + 1;
    }
    return $res;
  }
}

Scala

main function, Scala

val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
  println( "one item is greater than four" )
}
if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
  println( "every item is positive" )
}
val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
println( "part " + part.length )

The complete file

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

// companion object for static methods of operatorsOf static cnt == 3
object operatorsOf {
  def  any_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it <- __self ) {
      if ( cb(it) ) {
        return true
      }
    }
    return false
  }
  def  all_2( __self : collection.mutable.ArrayBuffer[Int], cb : (Int)=> Boolean) : Boolean = {
    for( it_1 <- __self ) {
      if ( cb(it_1) == false ) {
        return false
      }
    }
    return true
  }
  def  slice_3( __self : collection.mutable.ArrayBuffer[Int], start : Int, end : Int) : collection.mutable.ArrayBuffer[Int] = {
    var res : collection.mutable.ArrayBuffer[Int] = new collection.mutable.ArrayBuffer()
    val __len : Int = __self.length
    var from : Int = start
    var to : Int = end
    if ( from < 0 ) {
      from = 0
    }
    if ( to > __len ) {
      to = __len
    }
    var i_2 : Int = from
    try {
      val __break__ = new Breaks;
      __break__.breakable {
        while (i_2 < to) {
          val __continue__ = new Breaks;
          __continue__.breakable {
            res.append(__self(i_2))
            i_2 = i_2 + 1
          }
        }
      }
    }
    return res
  }
}

// application main function for Main
object AppMain extends App {
  val numbers : collection.mutable.ArrayBuffer[Int] = collection.mutable.ArrayBuffer(1, 2, 3, 4, 5)
  if ( operatorsOf.any_2(numbers, ((item : Int) => item > 4)) ) {
    println( "one item is greater than four" )
  }
  if ( operatorsOf.all_2(numbers, ((item : Int) => item > 0)) ) {
    println( "every item is positive" )
  }
  val part : collection.mutable.ArrayBuffer[Int] = operatorsOf.slice_3(numbers, 1, 3)
  println( "part " + part.length )
}

The Ranger source of the method

fn slice:[T] (start:int end:int) @doc('Items from `start` up to but not including `end`') {
    def res:[T]
    def len (array_length self)
    def from start
    def to end
    if( from < 0 ) {
        from = 0
    }
    if( to > len ) {
        to = len
    }
    def i from
    while( i < to ) {
        push res (itemAt self i)
        i = i + 1
    }
    return res
}

Definition: lib/stdlib.rgr, line 835

Map

Method	Arguments	Gives	Targets
forEach	cb: (fn:void (item:T index:K))	S	every target
get	key: K	T	every target
has	key: K	boolean	every target
keys	—	[K]	every target
set	key: K, value: T	S	every target

forEach

receiver.forEach(cb) → S

forEach(cb: (fn:void (item:T index:K)))

The compiler writes this method for every target.

The Ranger source of the method

fn  forEach@(weak):S ( cb:(_:void (item:T index:K)) ) {
    def keys (keys self.elements)
    for keys key:K i {
        cb( (unwrap (get self.elements key)) key )
    }
    return self
}

Definition: lib/stdlib.rgr, line 1182

get

receiver.get(key) → T

get(key: K)

The compiler writes this method for every target.

The Ranger source of the method

fn  get@(optional):T (key:K) {
    return (get self.elements key)
}

Definition: lib/stdlib.rgr, line 1163

has

receiver.has(key) → boolean

has(key: K)

The compiler writes this method for every target.

The Ranger source of the method

fn  has:boolean (key:K) {
    return (has self.elements key)
}

Definition: lib/stdlib.rgr, line 1166

keys

receiver.keys() → [K]

The compiler writes this method for every target.

The Ranger source of the method

fn  keys:[K] () {
    return (keys self.elements)
}

Definition: lib/stdlib.rgr, line 1160

set

receiver.set(key value) → S

set(key: K, value: T)

The compiler writes this method for every target.

The Ranger source of the method

fn  set:S (key:K value:T) {
    def c (new S)
    def keys ( keys self.elements)
    for keys k:string i {
        if(k==key) {

        } {
            set c.elements k (unwrap (get self.elements k))
        }
    }
    set c.elements key value
    return c
}

Definition: lib/stdlib.rgr, line 1169

Vector

Method	Arguments	Gives	Targets
array_length	—	int	every target
at	idx: int	T	every target
clear	idx: int	T	every target
forEach	cb: (fn:void (item:T))	void	every target
forUntil	cb: (fn:boolean (item:T))	void	every target
indexOf	elem: T	int	every target
itemAt	idx: int	T	every target
last	—	T	every target
length	—	int	every target
map	cb: (fn:K (item:T)), to: [K]	[K]	every target
map	cb: (fn:T (item:T))	S	every target
push	item: T	S	every target
size	—	int	every target

array_length

receiver.array_length() → int

The compiler writes this method for every target.

The Ranger source of the method

fn array_length:int () {
    return (self.count())
}

Definition: lib/stdlib.rgr, line 1099

at

receiver.at(idx) → T

at(idx: int)

The compiler writes this method for every target.

The Ranger source of the method

fn at:T (idx:int) {
    def val (self.get(idx))
    return val
}

Definition: lib/stdlib.rgr, line 1089

clear

receiver.clear(idx) → T

clear(idx: int)

The compiler writes this method for every target.

The Ranger source of the method

fn clear:T (idx:int) {
    ; def val (self.get(idx))
    return (new T)
}

Definition: lib/stdlib.rgr, line 1080

forEach

receiver.forEach(cb) → void

forEach(cb: (fn:void (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn forEach:void (cb:(_:void (item:T))) {
    def cnt (self.count())
    def i 0
    while( i < cnt ) {
        def item (itemAt self i)
        cb(item)
        i = i + 1
    }
}

Definition: lib/stdlib.rgr, line 1108

forUntil

receiver.forUntil(cb) → void

forUntil(cb: (fn:boolean (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn forUntil:void (cb:(_:boolean (item:T))) {
    def cnt (self.count())
    def i 0
    while( i < cnt ) {
        def item (itemAt self i)
        if( (cb(item)) == false ) {
            return
        }
        i = i + 1
    }
}

Definition: lib/stdlib.rgr, line 1118

indexOf

receiver.indexOf(elem) → int

indexOf(elem: T)

TODO: strict type checking for this fn for (iIndex@(ignore):T iteIndex@(ignore):int code:block ) ( "def " (e 3) ":int 0" nl "def loop_cnt (" (e 1) ".count())" nl "while( " (e 3) " < loop_cnt ) {" nl I "def " (e 2) " (" (e 1) ".get(" (e 3) "))" nl (block 4) (e 3) " = " (e 3) " + 1" nl i "}" nl )

The compiler writes this method for every target.

The Ranger source of the method

fn indexOf:int ( elem:T ) {
    def cnt (self.count())
    def i 0
    while( i < cnt ) {
        def item (itemAt self i)
        if(item == elem) {
            return i
        }
        i = i + 1
    }
    return -1
}

Definition: lib/stdlib.rgr, line 1068

itemAt

receiver.itemAt(idx) → T

itemAt(idx: int)

The compiler writes this method for every target.

The Ranger source of the method

fn itemAt:T (idx:int) {
    def val (self.get(idx))
    return val
}

Definition: lib/stdlib.rgr, line 1085

last

receiver.last() → T

The compiler writes this method for every target.

The Ranger source of the method

fn last:T () {
    return (itemAt self ((self.count()) - 1) )
}

Definition: lib/stdlib.rgr, line 1096

length

receiver.length() → int

The compiler writes this method for every target.

The Ranger source of the method

fn length:int () {
    return (self.count())
}

Definition: lib/stdlib.rgr, line 1102

map

receiver.map(cb to) → [K]

map(cb: (fn:K (item:T)), to: [K])

TODO: faster version ....

The compiler writes this method for every target.

The Ranger source of the method

fn map:[K] (cb:(_:K (item:T)) to@(noeval):[K] ) {
    def res:[K]
    def cnt (self.count())
    def i 0
    while( i < cnt ) {
        def item (itemAt self i)
        push res (cb(item))
        i = i + 1
    }
    return res
}

Definition: lib/stdlib.rgr, line 1144

map

receiver.map(cb) → S

map(cb: (fn:T (item:T)))

The compiler writes this method for every target.

The Ranger source of the method

fn map:S ( cb:(_:T (item:T)) ) {
    def res (new S)
    def cnt (self.count())
    def i 0
    while( i < cnt ) {
        def item (itemAt self i)
        def value (cb(item))
        res = res.add(value)
        i = i + 1
    }
    return res
}

Definition: lib/stdlib.rgr, line 1130

push

receiver.push(item) → S

push(item: T)

The compiler writes this method for every target.

The Ranger source of the method

fn push:S (item:T) {
    return (self.add(item))
}

Definition: lib/stdlib.rgr, line 1093

size

receiver.size() → int

The compiler writes this method for every target.

The Ranger source of the method

fn size:int () {
    return (self.count())
}

Definition: lib/stdlib.rgr, line 1105