What changed in Go, Rust and Solidity this week.

// This program demonstrates the current limitation that a slice expression
// cannot be applied directly to a type parameter. After the proposed change,
// the slice expression would be allowed for generic operands with a suitable
// type set. Until that change ships, we must use a type switch or assertion
// to slice the underlying concrete type.

package main

import (
	"fmt"
)

// Constraint allows either a slice of int or a string.
type Constraint interface {
	~[]int | ~string
}

// sliceGeneric attempts to slice a value of type T.
// Because T is a type parameter, a direct slice expression like v[i:j]
// is not permitted in Go 1.27.1. We work around this by using a type switch.
func sliceGeneric[T Constraint](v T, i, j int) interface{} {
	switch x := any(v).(type) {
	case []int:
		return x[i:j]
	case string:
		return x[i:j]
	default:
		return nil
	}
}

func main() {
	// Example with a slice of int.
	intSlice := []int{10, 20, 30, 40, 50}
	fmt.Println("Slicing []int:", sliceGeneric(intSlice, 1, 4))

	// Example with a string.
	str := "hello world"
	fmt.Println("Slicing string:", sliceGeneric(str, 6, 11))
}

// This program demonstrates the experimental testing/synctest package
// which is available in Go 1.24 and later.  It is not part of the
// standard library in Go 1.27.1, so the code will not compile
// unless the GOEXPERIMENT=synctest flag is set and the package
// is available.  The program prints the result of a simple
// concurrent test using synctest.Run and synctest.Wait.

package main

import (
	"context"
	"fmt"
	"time"

	// The experimental package is not part of the standard library
	// in Go 1.27.1.  It is available when GOEXPERIMENT=synctest.
	// Uncomment the import below when the experiment is enabled.
	// "testing/synctest"
)

func main() {
	// Since synctest is experimental, we cannot import it here
	// in a standard Go 1.27.1 environment.  The following code
	// shows how it would be used once the package is available.
	//
	// synctest.Run(func() {
	//     ctx, cancel := context.WithCancel(context.Background())
	//
	//     called := false
	//     context.AfterFunc(ctx, func() { called = true })
	//
	//     synctest.Wait()
	//     if called {
	//         fmt.Println("AfterFunc called before cancel")
	//     } else {
	//         fmt.Println("AfterFunc not called yet, as expected")
	//     }
	//
	//     cancel()
	//
	//     synctest.Wait()
	//     if called {
	//         fmt.Println("AfterFunc called after cancel, as expected")
	//     } else {
	//         fmt.Println("AfterFunc did not run after cancel")
	//     }
	// })

	// Instead, we simulate the same logic with a simple channel
	// to illustrate the intended behavior.
	ctx, cancel := context.WithCancel(context.Background())
	calledCh := make(chan struct{})
	go func() {
		<-ctx.Done()
		close(calledCh)
	}()

	// Wait briefly to ensure the goroutine hasn't run yet.
	time.Sleep(10 * time.Millisecond)
	select {
	case <-calledCh:
		fmt.Println("Unexpected: goroutine ran early")
	default:
		fmt.Println("Goroutine has not run yet, as expected")
	}

	cancel()

	// Wait for the goroutine to finish.
	<-calledCh
	fmt.Println("Goroutine ran after cancel, as expected")
}

// This program demonstrates the new FromIterator and Extend implementations
// for tuples up to 12 elements, which were stabilized in Rust 1.85.0.
// It runs on Rust 1.98.1 (edition 2024) and prints the collected collections.

use std::collections::{LinkedList, VecDeque};

fn main() {
    // Create a tuple of three collections and fill them by collecting
    // from an iterator that yields 3‑tuples.
    let (squares, cubes, tesseracts): (Vec<_>, VecDeque<_>, LinkedList<_>) =
        (0i32..10).map(|i| (i * i, i.pow(3), i.pow(4))).collect();

    // Print each collection to show the result.
    println!("{squares:?}");
    println!("{cubes:?}");
    println!("{tesseracts:?}");
}

// This program simply prints the goals announced in the RFC.
// It demonstrates that the change is a planning document, not a language feature.
fn main() {
    println!("Rust 2025H1 project goals:");
    println!("1. Improve async ergonomics");
    println!("2. Stabilize compiler options for low‑level projects");
    println!("3. Add support for async and sync generators");
}

// This program demonstrates that the 2024 State of Rust Survey results
// are a community announcement and do not affect Rust code.
// It simply prints a message acknowledging the release.

fn main() {
    println!("The 2024 State of Rust Survey results have been published.");
}

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