Error map
panic: attempt to divide by zero Rust: thread 'main' panicked at src/main.rs:3:13: attempt to divide by zero
Rust · layer 4, Application & API
Centre: this error. First ring: errors it is linked with (10). Outer ring: what those are linked with. Colours show the layer of a request each error belongs to. Click any dot to re-centre the map on it; hover to follow its connections. The centre dot opens the error page.
Directly related (10)
Go: panic: runtime error: index out of range [3] with length 3
Code accessed a slice, array or string element beyond its length.
Go: panic: runtime error: slice bounds out of range [:5] with capacity 3
A slice expression `s[a:b]` used bounds outside the slice's length or capacity.
Go: panic: runtime error: integer divide by zero
Integer division or modulo by zero.
Rust: thread 'main' panicked at src/main.rs:4:20: called `Option::unwrap()` on a `None` value
`unwrap()` (or `expect`) was called on `None`, so the program panicked.
Rust: thread 'main' panicked at src/main.rs:5:36: called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }
`unwrap()`/`expect()` was called on an `Err`, and the error value is shown in the panic message.
Rust: thread 'main' panicked at src/main.rs:5:5: index out of bounds: the len is 3 but the index is 3
A Vec/array/slice was indexed past its length.
Rust: thread 'main' panicked at src/main.rs:4:13: attempt to subtract with overflow
An arithmetic operation overflowed (in debug builds) — commonly `usize` underflow like `0 - 1`.
Rust: thread 'main' panicked at src/main.rs:8:9: already borrowed: BorrowMutError / already mutably borrowed: BorrowError
A `RefCell` was borrowed in conflicting ways at runtime (a mutable borrow while another borrow was alive).
Rust: thread 'main' has overflowed its stack — fatal runtime error: stack overflow
Recursion (or huge stack allocations) exhausted the thread's stack.
Rust: thread 'main' panicked: called `Result::unwrap()` on an `Err` value: PoisonError { .. } — poisoned lock: another task failed inside
A thread panicked while holding a `Mutex`/`RwLock`, so the lock is "poisoned" and `lock().unwrap()` panics for others.
Two steps away (9)
Go: panic: runtime error: invalid memory address or nil pointer dereference
The program used a pointer, map, interface or struct field that was nil — usually an uninitialised value or an ignored error.
Go: panic: assignment to entry in nil map
You wrote to a map that was declared but never initialised.
Go: panic: interface conversion: interface {} is string, not int
A type assertion `x.(T)` failed because the dynamic type of the interface is not T.
Go: runtime: goroutine stack exceeds 1000000000-byte limit — fatal error: stack overflow
Unbounded recursion consumed the goroutine's stack until it hit the 1 GB limit.
Go: panic: reflect: call of reflect.Value.Elem on zero Value
Reflection code operated on an invalid (zero) `reflect.Value`, often derived from a nil pointer or a missing struct field.
Rust: error[E0277]: the trait bound `Foo: Display` is not satisfied / `Rc<RefCell<T>>` cannot be sent between threads safely
A type doesn't implement a trait required by a function, macro or generic bound.
Rust: error[E0608]: cannot index into a value of type `HashSet<i32>` / `String` cannot be indexed by `{integer}`
The type doesn't support `[]` indexing (or not with that index type).
Rust: error[E0308]: mismatched types — expected `X`, found `Y`
A value’s type doesn’t match what the context expects — common with &str vs String, Option/Result vs plain values, and integer ty…
Rust: error[E0499]: cannot borrow `v` as mutable more than once at a time
Two mutable references to the same value were alive at once, which Rust forbids.
Map another error
Popular: 500403400ORA-009331064Critical errorFileNotFoundException assemblyTypeError