case class Peer(
  cidrs: List[String],
  pubkey: String,
  endpoint: String,
  keepalive: Int)

sealed trait WgCommand
case class InitConfig(…)
  extends WgCommand
case class SetPeer(peer: Peer)
  extends WgCommand
case class RemovePeer(pubkey: String)
  extends WgCommand

pub struct Peer {
    pub cidrs: Vec<String>,
    pub pubkey: String,
    pub endpoint: String,
    pub keepalive: u32,
}

struct Rgb (i8, i8, i8)

pub enum WgCommand {
    InitConfig(String, String, String, u32),
    SetPeer(Peer),
    RemovePeer(String)
}

command match {
    case InitConfig(
        ip,
        pub, priv,
        port) => …
    case SetPeer(peer) => …
    case RemovePeer(pub) => …
}

match cmd {
    WgCommand::InitConfig(
        ip, pubkey, privkey,
        port) => …,
    … 
}

trait Bidule {
    def abstractMethod(t: String): String
    def concrete(t: String): String =
      abstractMethod(t)
}

case class Machin(a: Int) extends Bidule

case class Truc(a: Int) {
    def yolo = a + 42
}

pub trait ProxyClient {
    fn front_socket(&self) -> &TcpStream
    …
}

pub struct Truc {
    pub a: u32,
}

impl Truc {
    fn new() -> Truc {
        Truc { a: 0 }
    },
    fn yolo(&self) -> u32 {
        self.a + 42
    }
}

let a = Truc::new();
let b = &a.yolo();

pub trait FromStr {
    type Err;
    fn from_str(s: &str) ->
      Result<Self, Self:Err>
}

impl FromStr for Bool {
    type Err = ParseBoolError;
    fn from_str(s: &str) -> {
        ...
    }
}

#[derive(Debug,PartialEq,Eq)]
pub struct {
    …
}

def myShinyMethod(t: String): String =
  ???

fn myShinyFunction(t: &str) -> String {
    unimplemented!()
}

def doThing(p: Param):
  Either[Error, Value] = …

fn do_thing(p: &Param) ->
  Result<Value, Error> {
    …
}

for {
    res1 <- op1() // yay scala 2.12,
                  // thanks Simon!
    res2 <- op2(res1)
} yield res2

fn do_things() -> Result<Value, Error> {
    let res1 = op1()?;
    let res2 = op2(res1)?;
    Ok(res2)
}

def mapTwice[A, F[_]: Functor](
    v: F[A],
    f: A => A
): F[A] = {
    …
}

static str
&str
String
[u8]
[u8,4]
Vec<u8>