What changed in Go, Rust and Solidity this week.

// This program demonstrates how Go’s slice operations preserve or change nilness.
// It uses only the standard library and runs in Go 1.27.1.

package main

import (
	"fmt"
)

func main() {
	// A nil slice of ints.
	var nilSlice []int

	// 1. Converting a nil slice to a typed nil slice.
	fmt.Printf("[]int(nil) is nil: %v\n", nilSlice == nil)

	// 2. Creating an empty slice with make.
	empty := make([]int, 0)
	fmt.Printf("make([]int, 0) is nil: %v\n", empty == nil)

	// 3. Slicing a nil slice to length 0 preserves nilness.
	sliced := nilSlice[:0]
	fmt.Printf("nilSlice[:0] is nil: %v\n", sliced == nil)

	// 4. Appending to a nil slice when the result is still empty.
	appended := append(nilSlice, []int{}...)
	fmt.Printf("append(nilSlice, []int{}...) is nil: %v\n", appended == nil)

	// 5. Appending a non‑empty element to a nil slice creates a non‑nil slice.
	appendedNonEmpty := append(nilSlice, 42)
	fmt.Printf("append(nilSlice, 42) is nil: %v\n", appendedNonEmpty == nil)
}

// This program simply prints a message. It is included to show that
// the current Rust 1.98.1 (edition 2024) compiler can run on MSVC
// and that the provenance feature is available. No new API is used.
fn main() {
    println!("Rust provenance is available on MSVC builds.");
}

// This program demonstrates the information from This Week in Rust 603.
// It prints the crate of the week and a brief note about the tooling highlights.
// No external crates are used, so it runs on Rust 1.98.1 (edition 2024).

fn main() {
    // Crate of the week
    println!("Crate of the week: optics");
    // Tooling highlights
    println!("Tooling highlights:");
    println!("  • Are We Embedded Yet? #2");
    println!("  • Meilisearch 1.15 – new typo tolerance setting, comparison operators for string filters, and improved support for Chinese");
}

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