@kenbitanga

struct Person { name: String, age: u32 } // &str is borrowed string fn print_person(name: &str) { print!("{}, ", name); }

let isShopOpen = true; let order = (time, work) => { return new Promise((resolve, reject) => { if (isShopOpen) { setTimeout(() => { resolve(work()); }, time); } else { reject(console

package main import "fmt" type Animal interface { feed() } type Dog struct { name string } func (d *Dog) feed() {

fn main() { println!("What is your age?"); let mut age = String::new(); std::io::stdin() .read_line(&mut age) .expect("Error"); let age: u32 = match age.trim().parse() {

package main import "fmt" type Animal interface { feed() } type Dog struct { name string

package main import "fmt" func sum(values []int) int { sum := 0 for _,v := range values { sum += v } return sum

fn fact(n: u32) -> u32 { if n < 2 { return 1; } return n * fact(n - 1); } fn main() { for i in 0..11 { println!("{}! = {}", i, fact(i)); } }

fn fib(n: u32) -> u32 { if n == 0 { return 0; } if n <= 2 { return 1; } return fib(n - 1) + fib(n - 2); } fn main() { for i in 0..11 { println!("fib({}) = {}", i, fib(i)); } }

fn main() { let mut string = String::new(); // append a char string.push('a'); // append a &str string.push_str("bcde"); // convert String to &str

fn main() { println!("What's your name?"); // create an empty growable String object let mut name = String::new(); // read user input std::io::stdin() .read_line(&mut name) .expect("Read line error");

use std::io; use rand::Rng; use std::cmp::Ordering; fn main() { println!("Guess the number!"); // generate random number from 1 to 100 let secret_number = rand::thread_rng().gen_range(1..=100);

fn fib(n: i32) -> i32 { if n < 1 { return 0; } else if n < 3 { return 1; } else { return fib(n - 1) + fib(n - 2); } } fn main() {

fn pass_str(s: &str) -> &str { return s; } fn pass_string(s: String) -> String { return s; } fn main() { // using string literal let test: &str = "Hello world!"; println!("{}", pass_str(test));

package main import "fmt" type Point struct { x int y int } func (p *Point) get() string { return fmt.Sprintf("Point(%v, %v)", p.x, p.y)

struct Point { x: f64, y: f64, } impl Point { // associated function // generally used as constructor fn origin() -> Point { Point { x: 0.0, y: 0.0 } }

fn main() { // create a tuple let tup = ("jake", 23); // destructure a tuple let (name, age) = tup; println!("{:?}", tup); println!("{} is {} years old", name, age); }

def sigma(n): res = n * (n + 1) / 2 # = (n + 1) * n / 2 # = (n * n / 2) + (n / 2) return int(res) for i in range(5): print('sigma({}) = {}'.format(i, sigma(i)))

def fact(n): if n < 0: return 'undefined' res = 1 for i in range(2, n+1): res *= i return res for i in range(-1, 5): print('{}! = {}'.format(i, fact(i)))

def fact(n): if n < 0: return 'undefined' if n <= 1: return 1 return n * fact(n-1) for i in range(-1, 7): print("{}! = {}".format(i, fact(i)))

def fact(n): if n < 0: return 'undefined' if n <= 1: return 1 return n * fact(n-1) for i in range(-1, 7): print("{}! = {}".format(i, fact(i)))