Go Animals From https://deadbeef.me/2018/01/go-gotchas

Animal.java

package sample.animals;
 
import java.lang.IllegalArgumentException;
import java.lang.String;
 
public class Animal {
    private String _name;
    private int _legs;
   
    public Animal(String name, int legs) {
        _name = name;
        _legs = legs;
    }
   
    public Animal setLegs(int legs) {
        if(legs < 0) {
            throw new IllegalArgumentException("Cannot have deficit of legs");
        }
        return new Animal(_name, legs);
    }
   
    public Animal setName(String name) {
        if(name.length() < 1) {
            throw new IllegalArgumentException("Name must be non-empty");
        }
        return new Animal(name, _legs);
    }
   
    public String getName() {
        return _name;
    }
   
    public int getLegs() {
        return _legs;
    }
   
    public String toString() {
        return String.format("{%s %d}", _name, _legs);
    }
}

animals-go.go

package main

import (
	"fmt"
)

type Animal struct {
	name string
	legs int
}

/*
 For some reason the signature:
    func (animals []Animal) bulkModify (f func(Animal) Animal) []Animal
 Doesn't work. This fixes that. #go-nuts on IRC advises against
*/
type Animals []Animal

func (animals Animals) bulkModifyMut(f func(Animal) Animal) Animals {
	for i, v := range animals {
		animals[i] = f(v)
	}
	return animals
}

func (animals Animals) bulkModify(f func(Animal) Animal) Animals {
	out := make(Animals, len(animals))
	copy(out, animals)
	return out.bulkModifyMut(f)
}

func manyLegs(animal Animal) Animal {
	animal.legs = 999
	return animal
}

func main() {
	zoo := Animals{Animal{"Dog", 4},
		Animal{"Chicken", 2},
		Animal{"Snail", 0},
	}
	fmt.Printf("-> Before update %v\n", zoo)
	fmt.Printf(
		"-> After update (updated) %v\n",
		zoo.bulkModify(manyLegs))
	fmt.Printf("-> After update (original) %v\n", zoo)
}

animals-rust.rust

#[derive(Debug)]
struct Animal {
	name: String,
	legs: u32
}

impl Animal {
    pub fn new(name: String, legs: u32) -> Animal {
	    Animal { name: name,
	           legs: legs }
	}
}

fn main() {
	let zoo : [Animal; 3] = [
	    Animal::new( "Dog".to_string(), 4 ),
		Animal::new( "Chicken".to_string(), 2 ),
		Animal::new( "Snail".to_string(), 0 ),
	];
	println!("-> Before update {:?}", zoo);
	println!("-> After update (modified) {:?}", zoo.iter()
        .map(|animal| { 
            Animal::new(animal.name.to_string(), 999)
        })
        .collect::<Vec<Animal>>() );
	println!("-> After update (modified) {:?}", zoo);
}

Application.java

package sample.animals;
 
import java.util.Arrays;
 
 
public final class Application {
    public static void main(String[] args) {
        Animal[] zoo = {
            new Animal("Dog", 4),
            new Animal("Chicken", 2),
            new Animal("Snail", 0)
        };
        System.out.printf("-> Before update %s\n", Arrays.toString(zoo));
        System.out.printf("-> After update (updated) %s\n", Arrays.toString(
                Arrays.stream(zoo).map(animal -> animal.setLegs(999)).toArray()
            )
        );
        System.out.printf("-> After update (original) %s\n", Arrays.toString(zoo));
       
    }
}