What changed in Go, Rust and Solidity this week.

// This program demonstrates that the standard library packages
// compile and run after the 1.25.13 security fixes. It does not
// perform network I/O because the sandbox has no network access.
package main

import (
	"html/template"
	"log"
	"os"
)

func main() {
	// Render a simple template to stdout.
	tmpl, err := template.New("hello").Parse("Hello, {{.Name}}!")
	if err != nil {
		log.Fatalf("template parse error: %v", err)
	}
	if err := tmpl.Execute(os.Stdout, struct{ Name string }{Name: "world"}); err != nil {
		log.Fatalf("template execute error: %v", err)
	}
}

// This program demonstrates that Go 1.26.6 contains no new API changes.
// It simply prints a message confirming that the language itself is unchanged.
package main

import "fmt"

func main() {
	fmt.Println("Go 1.26.6 does not introduce new language features.")
}

// This program demonstrates that the Rust language itself has not changed.
// The RFC only reorganises team membership; it does not affect code.
fn main() {
    println!("No Rust language change to demonstrate.");
}

// This example demonstrates the current way to restrict trait
// implementations and field mutability before the nightly features
// are available. It uses the sealed‑trait pattern for impl
// restriction and a private field with a public getter for mut
// restriction.

mod private {
    // The Sealed trait is private and cannot be named by downstream crates.
    pub trait Sealed {}
}

pub trait Foo: private::Sealed {
    fn method(&self);
}

// Only the types we choose can implement Sealed, so only they can
// implement Foo. This mimics the future `impl(crate)` syntax.
impl private::Sealed for usize {}
impl private::Sealed for i32 {}

impl Foo for usize {
    fn method(&self) {
        println!("usize implementation");
    }
}

impl Foo for i32 {
    fn method(&self) {
        println!("i32 implementation");
    }
}

// For field mutability, expose a read‑only field and provide a
// private setter. Downstream crates can read but cannot modify.
pub struct Bar {
    pub alpha: u8, // public read
    beta: u8,      // private write
}

impl Bar {
    // Public constructor
    pub fn new(alpha: u8, beta: u8) -> Self {
        Self { alpha, beta }
    }

    // Public getter for beta
    pub fn beta(&self) -> u8 {
        self.beta
    }

    // Private method to mutate beta
    fn set_beta(&mut self, v: u8) {
        self.beta = v;
    }
}

fn main() {
    // Trait implementation restriction works
    let x: usize = 5;
    x.method(); // prints "usize implementation"

    // Field mutability restriction works
    let mut b = Bar::new(10, 20);
    println!("alpha: {}, beta: {}", b.alpha, b.beta()); // read allowed
    // b.beta = 30; // ❌ cannot assign to private field
    b.set_beta(30); // ✅ only within the crate
}

// This program demonstrates the syntax error that existed before the change.
// It tries to use an implicit closing parenthesis after a type, which
// would have caused a compilation error in older Rust versions.
// In Rust 1.98.1 (edition 2024) this code does not compile because
// the implicit parenthesis is no longer accepted.
fn main() {
    // The following line would be illegal in older Rust:
    // let x: (i32) = 5;
    // Instead, write it without the extra parenthesis:
    let x: i32 = 5;
    println!("x = {}", x);
}

// 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");
    }
}