> ## Content Index
> Fetch the complete content index at: https://huizhou92.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Go 1.26: The `new(expr)` Feature — Simpler Pointer Creation, Clearer Code
- URL: https://huizhou92.com/go-1-26-the-new-expr-feature-simpler-pointer-creation-clearer-code/
- Published: 2025-10-06T14:44:41.000Z
- Updated: 2025-10-06T14:44:41.000Z
- Description: Go 1.26 introduces a small but elegant change: `new` can now take an expression, not just a type. Let’s explore what it means, why it…
- Author: huizhou92
- Tags: #Migrated-1788833207488, #Import 2026-09-08 02:07

#### Go 1.26 introduces a small but elegant change: \`new\` can now take an expression, not just a type. Let’s explore what it means, why it matters, and how the community reacted.

### 🚀 Introduction

In **Go 1.26**, the built-in function `new` receives a subtle yet elegant upgrade — it can now accept **an expression** instead of just a type.

This new syntax makes it easier to create pointers directly from values, improving readability and consistency across Go’s allocation patterns.

### 🧩 What Is `new(expr)`?

Before Go 1.26, you could only write:

```go
p := new(int)  // returns *int, initialized to 0
```

Starting in Go 1.26, you can now write:

```go
p := new(42)   // returns *int, initialized to 42
```

In short:

- `new(T)` — allocates a zero value of type `T`, returns `*T`.
- `new(expr)` — evaluates `expr`, copies its result into a new variable, and returns its pointer.

[Try It](https://go.dev/play/p/cc0aOdN%5FtJ4?v=gotip&ref=huizhou92.com)

### 🧠 Examples

### Simple values

```go
p := new("hello") 
fmt.Println(*p) // "hello"
```

### Structs

```go
type User struct { Name string } 
u := new(User{Name: "Alice"}) 
fmt.Println(*u) // {Alice}
```

### Function results

```go
f := func() int { return 99 } 
x := new(f()) 
fmt.Println(*x) // 99
```

### Invalid

```go
new(nil) // compile error
```

### 💡 Why Add This Feature?

1. **Less boilerplate**  
Before:

```go
v := 42 p := &v
```

Now:

```go
p := new(42)
```

1. **Consistency**  
 Go already allows `&T{...}` for struct literals, but not `&42` for basic values.  
`new(expr)` fills that gap without breaking language rules.
2. **Readability**  
 When you want “a pointer to this value,” `new(expr)` reads exactly as it behaves.

### ⚠️ Notes and Limitations

- The expression must have a concrete type (constants will infer their type).
- `new(nil)` is still illegal.
- Avoid side effects in the expression.
- Fully backward-compatible — no code breaks.

### 🌍 Community Reactions

The change sparked lively but upbeat discussion across Reddit, GitHub, and the Go proposal tracker.

### 👍 Overall sentiment: “Small but nice”

Most developers see it as a **minor yet satisfying quality-of-life improvement**, particularly those who wrote helper functions `PointerTo()` just to take the address of a value.

> *“Finally, I can delete my PointerTo() helper!” — Reddit user*

### ✅ Supporters highlight:

- Eliminates boilerplate pointer helpers.
- Unifies allocation syntax with `&T{}`.
- Enhances generic and testing code.
- Improves clarity: “pointer to a value” is explicit and readable.

### ⚖️ Skeptics mention:

1. **Why not just `&42`?**  
 Classic debate: address-of operator on untyped constants isn’t valid since such values have no allocated memory.  
`new(expr)` is a **safe, practical compromise**.
2. **Limited scope**  
 Some call it “a narrow convenience.”  
 Others argue that’s precisely why it’s good — low risk, low complexity, easy to adopt.
3. **Code style**  
 Teams agree it’s fine for *occasional pointer creation*, but shouldn’t replace struct literals or conventional variable declarations.

### 🧰 Tooling and Ecosystem

- Linters may soon suggest replacing helper functions with `new(expr)`.
- Backward-compatible — no migration needed.
- IDEs and editors already recognize the syntax.

### 🧭 Practical Tips

- ✅ Use `new(expr)` for temporary pointers (tests, configs, small values).
- ✅ Keep `&T{}` for structured initialization.
- 🚫 Don’t overuse it.
- 🚫 Avoid `new(nil)` — still invalid.

### 🔚 Conclusion

`new(expr)` is a tiny addition — yet it makes Go code feel smoother and more expressive.  
It unifies how we allocate and reference values without introducing new concepts or syntax noise. Another step in Go’s ongoing evolution toward **clarity through simplicity**.