func main() {
	v1 := "apple"
	v2 := v1
	fmt.Println(v1, v2) // apple apple
}

fn main() {
    let v1 = "apple".to_string();
    let v2 = v1;
    println!("{} {}", v1, v2);
}

    let v1 = "apple".to_string();
    let v2 = v1.clone();

func main() {
	var r *int
	{
		x := 5
		r = &x
	}
	fmt.Printf("f: %s", *r) // f: 5
}

fn main() {
    let r;
    {
        let x = 5;
        r = &x;
    }
    println!("r: {}", r);
}

fn main() {
    let s = String::new().trim();
    println!("{}", s);
}

let s = {
    let tmp = String::new();
    trim(tmp)
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

 --> src/main.rs:9:33
  |
9 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

x := "hello"
// 常に可変なので変更できる
x = "world"

let x = "hello";
// 不変なので変更できない
// output: cannot assign twice to immutable variable `x`  cannot assign twice to immutable variable
x = "world";

let mut x = "hello";
// 可変なので変更できる
x = "world";

#[derive(Default)]
struct User {
    first_name: String,
    last_name: String,
}

impl User {
    // メソッドの実装
    pub fn full_name(&self) -> String {
        self.first_name.clone() + &self.last_name
    }

    pub fn change_first_name(&mut self, name: String) {
        self.first_name = name;
    }
}

fn main() {
    let user = User::default();
    // 不変なので`full_name()`を呼べる
    user.full_name();
    // エラー: cannot borrow `user` as mutable, as it is not declared as mutable
    // user.change_first_name("new nick name".into());

    let mut user = user;
    // 可変なので`change_first_name()`を呼べる
    user.change_first_name("new nick name".into());
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

type Coin int

const (
	Penny Coin = iota + 1
	Nickel
	Dime
	Quarter
)

func valueInCents(coin Coin) int {
	switch coin {
	case Penny:
		return 1
	case Nickel:
		return 5
	case Dime:
		return 10
	case Quarter:
		return 25
	default:
		return 0
	}
}

let x = 9;
let message = match x {
    0 | 1  => "not many", // 0 または 1
    2 ..= 9 => "a few",   // 2 ~ 9 まで
    _      => "lots"      // それ以外
};

var value string
if condition {
	value = "true_value"
} else {
	value = "false_value"
}

let value = if condition {
    "true_value"
} else {
    "false_value"
};

fn main() {
    let echo = |name| {
        println!("hello {}", name);
    };

    echo("gorilla");
    echo("godzilla");
}

func main() {
	echo := func(name string) {
		fmt.Printf("hello, %s!\n", name)
	}

	echo("gorilla")
	echo("godzilla")
}

fn call_closure(f: impl Fn()) {
    f();
}

fn main() {
    let mut v = "value".to_string();
    let change_v = || {
        v = "new value".to_string();
    };

    call_closure(change_v);
    println!("{}", v);
}

diff --git a/hello/src/main.rs b/hello/src/main.rs
index f0e568b..595b50f 100644
--- a/hello/src/main.rs
+++ b/hello/src/main.rs
@@ -1,4 +1,4 @@
-fn call_closure(f: impl Fn()) {
+fn call_closure(mut f: impl FnMut()) {
     f();
 }

func callClosure(f func()) {
	f()
}

func main() {
	v := "value"
	echo := func() {
		v = "new value"
	}
	callClosure(echo)
	fmt.Println(v)
}

func readFile(file string) (string, error) {
	f, err := os.Open(file)
	if err != nil {
		return "", nil
	}
	defer f.Close() // readFileを抜ける際に`f.Close()`を実行する
	b, err := io.ReadAll(f)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

struct Droppable {
    name: &'static str,
}

impl Drop for Droppable {
    fn drop(&mut self) {
        println!("> Dropping {}", self.name);
    }
}

fn main() {
    let _a = Droppable { name: "a" };

    {
        let _b = Droppable { name: "b" };
        {
            let _c = Droppable { name: "c" };
            let _d = Droppable { name: "d" };

            println!("Exiting block B");
        }
        println!("Just exited block B");

        println!("Exiting block A");
    }
}

$ cargo run -q
Exiting block B
> Dropping d
> Dropping c
Just exited block B
Exiting block A
> Dropping b
> Dropping a

for _, filename := range []string{"file1", "file2", "file3"} {
  file, err := os.Open(filename)
  if err != nil {
    // error handling
    continue
  }
  // do something with the file
  defer file.Close()
}

for filename in vec!["file1", "file2", "file3"] {
    let file = std::fs::OpenOptions::new().open(filename).unwrap();
    // do somethign with file
}

let list = vec![1, 2, 3];

let list = <[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([1, 2, 3]));

#[macro_export]
macro_rules! my_vec {
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

fn main() {
    // 展開後はこんな感じになる
    // let v = {
    //     let mut temp_vec = Vec::new();
    //     temp_vec.push(1);
    //     temp_vec.push(2);
    //     temp_vec.push(3);
    //     temp_vec.push(4);
    //     temp_vec.push(5);
    //     temp_vec
    // };
    let v = my_vec![1, 2, 3, 4, 5];
    println!("{:?}", v);
}

// #[derive(ここにマクロ名)]
#[derive(Debug)]
struct S(String);

struct S(String);
#[automatically_derived]
impl ::core::fmt::Debug for S {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "S", &&self.0)
    }
}

#[tokio::main]
async fn main() {
    // .awaitで関数の実行が終わるまで待つ
    async_hello().await;

    println!("Thread finished!")
}

let sql = sql!(SELECT * FROM posts WHERE id=1);

type Input struct {
	Name     string
	NickName *string
}

// nilの場合はpanicする
// コンパイルエラーにならない
nickName := *input.NickName

struct Input {
    name: String,
    nick_name: Option<String>,
}

match input.nick_name {
    Some(nick_name) => {
        // do something
    }
    None => {
        // do something
    }
}

func readFile(file string) ([]byte, error) {
	f, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	return os.ReadFile(file)
}

bytes, err := readFile("tmp.txt")
if err != nil {
	// handle error
}

// 無視する場合
bytes, _ := readFile("tmp.txt")

use std::io::Read as _;

fn read_file(file: String) -> Result<Vec<u8>, std::io::Error> {
    let mut file = std::fs::File::open(file)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;
    Ok(buffer)
}

let result = read_file("tmp.txt".into());
let bytes = match result {
    Ok(bytes) => bytes
    Err(e) => {
        // error handling
        return Err(e);
    }
}

let bytes = read_file("tmp.txt".into())?;

type Status interface {
	isStatus()
}

type status string

func (s status) isStatus() {}

const (
	Unknown  status = "Unknown"
	Active   status = "Active"
	Inactive status = "Inactive"
)

func printStatus[T Status](status T) {
	fmt.Println("Status:", status)
}

func main() {
	printStatus(Unknown)
	printStatus(Active)
	printStatus("Foo") // output: string does not satisfy StatusEnum (missing method isStatusEnum)
}

printStatus(status("Foo"))

#[derive(Debug)]
enum Status {
    Unknown,
    Active,
    Inactive,
}

fn print_status(status: Status) {
    println!("The status is {:?}", status);
}

fn main() {
    print_status(Status::Active);
    print_status(Status::Inactive);
}

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);

let loopback = IpAddr::V6(String::from("::1"));

pub enum Result<T, E> {
    /// Contains the success value
    #[lang = "Ok"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    #[lang = "Err"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
}

type Writer interface {
	Write([]byte) (int, error)
}

type MyWriter struct {
	buf []byte
}

func (w *MyWriter) Write(data []byte) (int, error) {
	w.buf = append(w.buf, data...)
	return len(data), nil
}

func write(w Writer, data []byte) (int, error) {
	return w.Write(data)
}

trait Writer {
    fn write(&mut self, buf: &mut Vec<u8>) -> Result<usize, String>;
}

struct MyWriter(Vec<u8>);

impl Writer for MyWriter {
    fn write(&mut self, buf: &mut Vec<u8>) -> Result<usize, String> {
        self.0.append(buf);
        Ok(buf.len())
    }
}

fn write(writer: &mut impl Writer, buf: &mut Vec<u8>) -> Result<usize, String> {
    writer.write(buf)
}

trait Currency {
    // 定数を定義することで
    // トレイトを実装する際は定数も必須になる
    const SYMBOL: &'static str;

    // メソッドを実装することでデフォルト実装を表現できる
    // それにより、トレイトを実装する際はメソッドの実装は必須じゃなくなる
    fn value(&self) -> f64 {
        0.0
    }
}

struct USD(f64);

impl Currency for USD {
    const SYMBOL: &'static str = "$";

    fn value(&self) -> f64 {
        self.0
    }
}

struct EUR(f64);

impl Currency for EUR {
    const SYMBOL: &'static str = "€";

    fn value(&self) -> f64 {
        self.0
    }
}

fn main() {
    let usd = USD(100.0);
    let eur = EUR(85.0);

    println!("The amount in USD is {}{}", USD::SYMBOL, usd.value());
    println!("The amount in EUR is {}{}", EUR::SYMBOL, eur.value());
}

func x[Bytes []byte | string](b Bytes) {
}

type Writer interface {
	Write([]byte) (int, error)
}

func write[T Writer](w T, data []byte) {
	w.Write(data)
}

struct S;

fn f<T: S>(_f: T) {} // expected trait, found struct `S` not a trait

trait Writer {
    fn write(&mut self, data: &[u8]);
}

fn write<T: Writer>(writer: &mut T, data: &[u8]) {
    writer.write(data);
}

type Processor struct {}

func (p *Processor) Process[T any](data T) T { // method must have no type parameters
	return data
}

struct Processsor;

impl Processsor {
    fn process<T>(&self) -> T {
        // implementation
    }
}

type Writer interface {
	Write([]byte) (int, error)
}

type Closer interface {
	Close() error
}

type WriteCloser interface {
	Writer
	Closer
}

func write[T WriteCloser](wc T, data []byte) {
	defer wc.Close()
	wc.Write(data)
}

trait Writer {
    fn write(&mut self, data: &[u8]);
}

trait Closer {
    fn close(&mut self);
}

fn write<T: Writer + Closer>(wc: &mut T, data: &[u8]) {
    wc.write(data);
}

// コンパイル前
let integer = Some(5);
let float = Some(5.0);

// コンパイル後
enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

func TestFoo(t *testing.T) {
	got := "gorilla"
	want := "gorilla"
	if !reflect.DeepEqual(want, got) {
		t.Errorf("unexpected result got: %v, want: %v", got, want)
	}
}

func Test1(t *testing.T) {
	t.Run("sub1", func(t *testing.T) {
		...
	})

	t.Run("sub2", func(t *testing.T) {
		...
	})
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_foo() {
        let got = "gorilla";
        let want = "gorilla";
        assert_eq!(got, want);
    }
}

.
├── Cargo.lock
├── Cargo.toml
├── src // ソースコード
│   └── main.rs
└── tests // 結合テスト
    └── integration.rs 

/// This is a simple function that adds two numbers.
/// Examples
/// ```
/// use hello::add;
/// let x = 5;
/// let y = 6;
/// assert_eq!(add(x, y), 11);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

running 1 test
test src/lib.rs - add (line 3) ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.13s

running 1 test
test src/lib.rs - add (line 3) ... FAILED

failures:

---- src/lib.rs - add (line 3) stdout ----
Test executable failed (exit status: 101).

stderr:
thread 'main' panicked at src/lib.rs:8:1:
assertion `left == right` failed
  left: 11
 right: 12
（略）

func Test1(t *testing.T) {
	t.Parallel()
	...
}

cargo test -- --test-threads=1

func main() {
	go func() {
		fmt.Println("Hello from a goroutine")
	}()
	// goroutineが実行されるの少し待つ
	time.Sleep(1*time.Second)
	fmt.Println("main function exited")
}

func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println("Hello from a goroutine")
	}()

	// goroutineの処理が終わるのを待つ
	wg.Wait()
	fmt.Println("main function exited")
}

fn main() {
    let handle = std::thread::spawn(|| {
        println!("Hello from a thread!");
    });

    // joinでスレッドの処理が終わるのを持つ
    handle.join().unwrap();
    println!("Thread finished!")
}

async fn async_hello() {
    println!("Hello from async function!");
}

#[tokio::main]
async fn main() {
    // .awaitで関数の実行が終わるまで待つ
    async_hello().await;

    println!("Thread finished!")
}

#[tokio::main]
async fn main() {
    let async_something = async {
        1
    };

    println!("{}", async_something.await);
}

pub trait Future {
    type Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

async fn fetch_data() -> String {
    sleep(Duration::from_secs(1)).await;
    "Data fetched".to_string()
}

struct FetchData {
    sleep: Pin<Box<Sleep>>,
}

impl Future for FetchData {
    type Output = String;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let sleep = self.get_mut().sleep.as_mut();
        match sleep.poll(cx) {
            Poll::Ready(_) => Poll::Ready("Data fetched".to_string()),
            Poll::Pending => Poll::Pending,
        }
    }
}

fn fetch_data() -> FetchData {
    FetchData {
        sleep: Box::pin(sleep(Duration::from_secs(1))),
    }
}

pub enum Poll<T> {
    Ready(T),
    Pending,
}

use tokio::task;

#[tokio::main]
async fn main() {
    let v = vec![1, 2, 3];

    task::spawn(async {
        println!("Here's a vec: {:?}", v);
    })
    .await
    .unwrap();
}

 async fn main() {
     let v = vec![1, 2, 3];
 
-    task::spawn(async {
+    task::spawn(async move {
         println!("Here's a vec: {:?}", v);
     })
     .await

use std::sync::Arc;
use tokio::task;

#[tokio::main]
async fn main() {
    let v = Arc::new(vec![1, 2, 3]);

    {
        // cloneすることで参照カウントが+1される
        // asyncブロックを抜けるとdropので、カウントが-1される
        // カウントが0になればメモリから削除される
        let v = v.clone();
        task::spawn(async move {
            println!("Here's a vec: {:?}", v);
        })
        .await
        .unwrap();
    }

    {
        let v = v.clone();
        task::spawn(async move {
            println!("Here's a vec: {:?}", v);
        })
        .await
        .unwrap();
    }
}

func main() {
	v := []int{1, 2, 3}

	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Printf("v: %v\n", v)
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Printf("v: %v\n", v)
	}()

	wg.Wait()
}

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	urls := []string{
		"url1",
		"url2",
		"url3",
	}

	results := map[string][]byte{}
	var wg sync.WaitGroup

	for _, url := range urls {
		wg.Add(1)
		go func(url string) {
			defer wg.Done()
			fmt.Printf("fetching %s\n", url)
			time.Sleep(1 * time.Second)
			body := []byte{} // some response body
			results[url] = body
		}(url)
	}

	wg.Wait()
	fmt.Printf("%#+v\n", results)
}

$ go run .
fetching url3
fetching url1
fetching url2
fatal error: concurrent map writes

$ go run -race .
fetching url3
fetching url2
fetching url1
==================
WARNING: DATA RACE
Write at 0x00c0000940c0 by goroutine 7:
  runtime.mapaccess2_faststr()
略）

@@ -13,6 +13,7 @@ func main() {
 		"url3",
 	}
 
+	var mutex sync.Mutex
 	results := map[string][]byte{}
 	var wg sync.WaitGroup
 
@@ -23,7 +24,9 @@ func main() {
 			fmt.Printf("fetching %s\n", url)
 			time.Sleep(1 * time.Second)
 			body := []byte{} // some response body
+			mutex.Lock()
+			defer mutex.Unlock()
 			results[url] = body
 		}(url)
 	}
 

use std::{collections::HashMap, sync::Arc, time::Duration};
use tokio::time::sleep;

#[tokio::main]
async fn main() {
    let urls = vec!["url1", "url2", "url3"];
    let results = Arc::new(HashMap::<String, Vec<u8>>::default());
    let mut tasks = Vec::with_capacity(urls.len());

    for url in urls {
        let results = results.clone();
        tasks.push(tokio::spawn(async move {
            println!("fetching {}", url);
            sleep(Duration::from_secs(1)).await;
            let body = vec![]; // some response body
            results.insert(url.into(), body);
        }));
    }

    for task in tasks {
        task.await.unwrap();
    }

    println!("{:?}", results);
}

$ cargo run
   Compiling hello v0.1.0 (/Users/skanehira/dev/github.com/skanehira/sandbox/rust/hello)
error[E0596]: cannot borrow data in an `Arc` as mutable
  --> src/main.rs:16:13
   |
16 |             results.insert(url.into(), body);
   |             ^^^^^^^ cannot borrow as mutable
   |
   = help: trait `DerefMut` is required to modify through a dereference, but it is not implement
ed for `Arc<HashMap<String, Vec<u8>>>`

 use std::{collections::HashMap, sync::Arc, time::Duration};
-use tokio::time::sleep;
+use tokio::{sync::Mutex, time::sleep};
 
 #[tokio::main]
 async fn main() {
     let urls = vec!["url1", "url2", "url3"];
-    let results = Arc::new(HashMap::<String, Vec<u8>>::default());
+    let results = Arc::new(Mutex::new(HashMap::<String, Vec<u8>>::default()));
     let mut tasks = Vec::with_capacity(urls.len());
 
     for url in urls {
@@ -13,7 +13,7 @@ async fn main() {
             println!("fetching {}", url);
             sleep(Duration::from_secs(1)).await;
             let body = vec![]; // some response body
-            results.insert(url.into(), body);
+            results.lock().await.insert(url.into(), body);
         }));
     }
 
@@ -21,5 +21,5 @@ async fn main() {
         task.await.unwrap();
     }
 
-    println!("{:?}", results);
+    println!("{:?}", results.lock().await);
 }

use std::sync::Arc;
use tokio::sync::Mutex;

struct A;

impl A {
    pub async fn do_something(&self) -> Result<(), ()> {
        Err(())
    }
}

async fn lock_and_use(a: Arc<Mutex<A>>) {
    match a.clone().lock().await.do_something().await {
        Ok(()) => {}
        Err(()) => {
            println!("trying again");
            // ここロック待ちになる
            let _ = a.clone().lock().await.do_something().await;
        }
    }
}

#[tokio::main]
async fn main() {
    println!("begin");
    let a = Arc::new(Mutex::new(A));
    lock_and_use(a.clone()).await;
    println!("end");
}

 async fn lock_and_use(a: Arc<Mutex<A>>) {
-    match a.clone().lock().await.do_something().await {
+    let value = a.clone().lock().await.do_something().await;
+    match value {
         Ok(()) => {}
         Err(()) => {
             println!("trying again");

[package]
name = "hello"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

[dependencies]
rand = "0.8.5"

module hello

go 1.22.0

go get github.com/google/go-cmp

module hello

go 1.22.0

require github.com/google/go-cmp v0.6.0

[profile.dev]
opt-level = 1 # 最適化のレベル

[lints.rust]
unsafe_code = "deny" # unsafe を禁止

mod foo {
    fn bar() {}
}

pub fn call_bar() {
    foo::bar();
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_foo() {
        let got = "gorilla";
        let want = "gorilla";
        assert_eq!(got, want);
    }
}

[features]
default = []
featureX = []

fn main() {
    println!("Default build");
    feature_x();
}

#[cfg(feature = "featureX")]
fn feature_x() {
    println!("Feature X is enabled");
}

#[cfg(not(feature = "featureX"))]
fn feature_x() {
    // `featureX`が有効でない場合のデフォルト動作
}

# デフォルトのコンパイル
$ cargo run -q
Default build

# --features で feature フラグを指定して実行する
$ cargo run -q --features featureX
Default build
Feature X is enabled

//go:build !featureX

package main

func featureX() {
	// Feature X is not enabled, so do nothing
}

//go:build featureX

package main

import "fmt"

func featureX() {
	fmt.Println("Feature X is enabled")
}

package main

import "fmt"

func main() {
	fmt.Println("Default build")
	featureX()
}

$ go run .               
Default build

$ go run -tags featureX .
Default build
Feature X is enabled

pub(in crate::foo) fn do_something() {
    println!("This function is public only within module 'a'.");
}

[dependencies]
regex = { git = "https://github.com/rust-lang/regex.git", branch = "next" }

    warning: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
 --> src/lib.rs:1:28
  |
1 |     fn sum_squares(values: &Vec<i32>) -> i32 {
  |                            ^^^^^^^^^ help: change this to: `&[i32]`
  |
  = note: `#[warn(clippy::ptr_arg)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg

[profile.dev]
opt-level = 0

[profile.release-lto]
inherits = "release"
lto = true

cargo build --profile release-lto

rustup target add x86_64-pc-windows-gnu

$ ll ~/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/x86_64-pc-windows-gnu/lib   
drwxr-xr-x skanehira staff 1.1 KB 2024-08-10 09:37:39  .
drwxr-xr-x skanehira staff  96 B  2024-08-10 09:37:39  ..
.rw-r--r-- skanehira staff 398 KB 2024-08-10 09:37:39  libaddr2line-cafead5e166395dc.rlib
.rw-r--r-- skanehira staff  29 KB 2024-08-10 09:37:38  libadler-a78f8ec11f17a280.rlib
.rw-r--r-- skanehira staff 5.5 MB 2024-08-10 09:37:39  liballoc-0d87392afa62cfaa.rlib
.rw-r--r-- skanehira staff 8.6 KB 2024-08-10 09:37:39  libcfg_if-6be57f0603b9b79d.rlib
（略）

brew install mingw-w64

$ cargo build --target x86_64-pc-windows-gnu

$ file target/x86_64-pc-windows-gnu/debug/hello.exe 
target/x86_64-pc-windows-gnu/debug/hello.exe: PE32+ executable (console) x86-64, for MS Windows

$ CROSS_CONTAINER_OPTS="--platform linux/x86_64" cross build --target x86_64-pc-windows-gnu