What changed in Go, Rust and Solidity this week.

// This program demonstrates that the `-ex` flag for `go doc` is not
// available in Go 1.27.1. It simply prints a message indicating the
// missing feature.

package main

import "fmt"

func main() {
	// In Go 1.27.1, `go doc` does not support the `-ex` flag, so we
	// cannot request examples directly from the command line.
	fmt.Println("The `-ex` flag for `go doc` is not available in Go 1.27.1.")
}

// This program demonstrates a simple recursive type that compiles
// thanks to Go 1.26's improved type construction. It prints the
// size of the slice element type to show that the compiler has
// resolved the recursion.

package main

import (
	"fmt"
	"unsafe"
)

// Node is a recursive type: each node points to another Node.
type Node struct {
	next *Node
}

func main() {
	// Create a slice of Nodes to exercise the recursive type.
	nodes := make([]Node, 3)

	// Link the nodes together.
	for i := 0; i < 2; i++ {
		nodes[i].next = &nodes[i+1]
	}

	// Print the size of the Node type to confirm the compiler
	// has constructed it correctly. The size includes a pointer.
	fmt.Printf("Size of Node: %d bytes\n", unsafe.Sizeof(Node{}))
}

// This program demonstrates that Rust 1.94.1 is available and compiles.
// It does not use any new API, because 1.94.1 only contains bug fixes.
fn main() {
    println!("Rust 1.94.1 is installed and running.");
}

// This program demonstrates the new Option::map_or_default and Result::map_or_default.
// It is written for Rust 1.98.1 (edition 2024) and compiles as is.

fn main() {
    // Example with Option
    let opt_some: Option<i32> = Some(10);
    let opt_none: Option<i32> = None;

    // Using map_or_default: if Some, double the value; if None, use i32::default() which is 0.
    let doubled = opt_some.map_or_default(|v| v * 2);
    let defaulted = opt_none.map_or_default(|v| v * 2);

    println!("doubled: {}", doubled);     // prints 20
    println!("defaulted: {}", defaulted); // prints 0

    // Example with Result
    let res_ok: Result<&str, &str> = Ok("hello");
    let res_err: Result<&str, &str> = Err("error");

    // map_or_default on Result: if Ok, convert to uppercase; if Err, use default &str which is "".
    let uppercased = res_ok.map_or_default(|s| s.to_uppercase());
    let defaulted_err = res_err.map_or_default(|s| s.to_uppercase());

    println!("uppercased: {}", uppercased);     // prints HELLO
    println!("defaulted_err: {}", defaulted_err); // prints empty string
}

// This program simply prints the message from the February 2026 program‑management update.
// The update does not introduce any new Rust language feature, so the code is unchanged
// from a typical “Hello, world!” example.

fn main() {
    println!("Program‑management update – February 2026");
}

// This program demonstrates that the change only affects RFC formatting,
// not Rust code.  It simply prints a message.
fn main() {
    println!("RFC heading levels are now level‑2; no code impact.");
}

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