What changed in Go, Rust and Solidity this week.

// This program demonstrates a simple use of the net/http package.
// It builds an HTTP GET request and prints the request URL and method.
// The program does not perform a network call, so it runs safely in a sandbox.
package main

import (
	"fmt"
	"net/http"
)

func main() {
	// Construct a new GET request to a placeholder URL.
	req, err := http.NewRequest("GET", "https://example.com", nil)
	if err != nil {
		// In real code you would handle the error appropriately.
		fmt.Println("Error creating request:", err)
		return
	}

	// Print the request details to show that net/http is working.
	fmt.Println("Method:", req.Method)
	fmt.Println("URL:", req.URL.String())
}

// This program demonstrates the issue that the new trait solver fixes.
// In the current stable compiler (1.98.1, edition 2024) the following
// function would not compile because the return type is `impl Sized` and
// the compiler cannot add an integer to it.  With the next‑generation
// solver enabled on nightly, the code would compile and work as intended.
//
// Here we use a concrete return type (`i32`) so that the program compiles
// on the stable compiler and still shows the same logic.

fn foo(b: bool) -> i32 {
    if b {
        // In the new solver this would be `foo(false) + 1` where the
        // return type is `impl Sized`.  We use `i32` instead.
        foo(false) + 1
    } else {
        0
    }
}

fn main() {
    let value = foo(true);
    println!("Result: {}", value);
}

// This program demonstrates the effect of the nightly-only `-Zembed-metadata=no` flag.
// Since the flag is not available on stable, we simply print a message explaining
// what would happen if it were enabled.

fn main() {
    println!("On nightly, Cargo automatically passes `-Zembed-metadata=no` to rustc,");
    println!("which removes duplicate metadata from .rlib files and reduces the");
    println!("size of the target directory. This change is experimental and only");
    println!("affects nightly builds.");
}

// This program demonstrates the current stable way to call an overloaded
// function that expects a tuple of arguments. The nightly `splat` feature
// is not available in Rust 1.98.1, so we use the tuple syntax instead.
fn hypot(args: (f64, f64, f64)) -> f64 {
    // In a real FFI scenario this would call into C++.
    // Here we just compute the Euclidean norm.
    let (x, y, z) = args;
    (x * x + y * y + z * z).sqrt()
}

fn main() {
    // Call with a tuple: (2.0, 3.0, 6.0)
    let result = hypot((2.0, 3.0, 6.0));
    println!("hypot(2.0, 3.0, 6.0) = {}", result);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}