core3 0.1.2

The bare essentials of std::io for use in no_std. Drop-in successor to core2. core2 alternative with some additional utils.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

# oxidex core3


~ Made this for my own needs but anyone who wants it can use it. 

A `no_std` replacement for [`core2`](https://crates.io/crates/core2). Provides the essential `std::io` traits (`Read`, `Write`, `Seek`, `BufRead`, `Cursor`) for `no_std` environments.

If you're here because `core2` was yanked and you need a drop-in alternative, this is it.

Forked from core2 v0.4.0. Modernized for current Rust:

- **Removed** the `error::Error` trait polyfill (stable in `core` since Rust 1.81)
- **Removed** nightly-only items (`BufReader`, `BufWriter`, `LineWriter`)
- **MSRV: 1.81**
- Single dependency: [`memchr`](https://crates.io/crates/memchr)


## Usage

```toml
[dependencies]
core3 = { version = "0.1", default-features = false }
```

```rust
use core3::io::{Read, Write, Cursor};
```

## Features

| Feature | Default | Description |
|---------|---------|-------------|
| `std`   | ✅      | Re-exports `std::io` directly |
| `alloc` | via std | Enables `Vec<u8>` Write impl and allocating Read methods |

For `no_std` without alloc:

```toml
core3 = { version = "0.1", default-features = false }
```

For `no_std` with alloc:

```toml
core3 = { version = "0.1", default-features = false, features = ["alloc"] }
```

## API

**Traits:** `Read`, `Write`, `Seek`, `BufRead`

**Structs:** `Cursor`, `Bytes`, `Chain`, `Take`, `Empty`, `Repeat`, `Sink`

**Enums:** `SeekFrom`, `ErrorKind`

**Types:** `Error`, `Result`

**Free functions:** `copy`, `empty`, `repeat`, `sink`

### Utilities

These mirror their `std::io` equivalents and work in `no_std`:

| Function | Needs `alloc` | Description |
|----------|:---:|-------------|
| `copy(reader, writer)` | no | Stream all bytes from a reader into a writer |
| `empty()` | no | Returns a reader that is always at EOF |
| `sink()` | no | Returns a writer that discards all data |
| `repeat(byte)` | no | Returns a reader that endlessly yields one byte |

### Additional trait methods (beyond core2)

| Method | Needs `alloc` | Description |
|--------|:---:|-------------|
| `Read::read_to_string()` | yes | Read all bytes into a `String`, errors on invalid UTF-8 |
| `BufRead::read_until(byte, buf)` | yes | Read until a delimiter byte or EOF |
| `BufRead::read_line(buf)` | yes | Read until newline into a `String` |

## Migrating from core2

### `Initializer` is deprecated

The `Initializer` type and `Read::initializer()` method from core2 are preserved
but deprecated. These mirrored an unstable std API (`#![feature(read_initializer)]`)
that was never stabilized. Zero-initialize buffers before calling `read()` instead.

Replace the dependency:

```toml
# Before
core2 = { version = "0.4", default-features = false }
# After
core3 = { version = "0.1", default-features = false }
```

Then update imports:

```rust
// Before
use core2::io::{Read, Write};

// After
use core3::io::{Read, Write};
```

## Why does this exist?

In April 2026 all versions of core2 were yanked. `core::error::Error` was stabilized in Rust 1.81 (September 2024), so the error polyfill is no longer needed. The I/O traits (`Read`, `Write`, `Seek`, `BufRead`, `Cursor`) still have no equivalent in `core`.

This crate extracts just the I/O components that the ecosystem still needs.

## Alternatives

If core3 isn't the right fit, consider [`no-std-io2`](https://github.com/wcampbell0x2a/no-std-io2), a maintained fork of core2.

## License

Apache-2.0 OR MIT (same as the original core2)