There's a issue out there stating similar problems, but it seems to relate with Serialize
trait and serde
library, which I did not use.
The problem appears in a project with single source file, and I was testing out a logically complex(?) enum, and rustc just overflows its stack.
use std::cell::RefCell;
use std::collections::LinkedList;
use std::ops::{Index, Range};
enum WhList<'a, T> {
Single(T),
Vector(Vec<T>),
Chain(&'a WhList<'a, T>, &'a WhList<'a, T>),
Append(&'a WhList<'a, T>, T),
Overlay(&'a WhList<'a, T>, &'a WhList<'a, Option<T>>),
Shadow(&'a WhList<'a, T>, usize, T),
Slice(&'a WhList<'a, T>, usize, usize)
}
impl <'a, T> WhList<'a, T> {
fn len(&'a self) -> usize {
match self {
WhList::Single(_) => 1,
WhList::Vector(vec) => vec.len(),
WhList::Chain(whl, whr) => whl.len() + whr.len(),
WhList::Append(whl, _) => whl.len() + 1,
WhList::Overlay(whl, _) => whl.len(),
WhList::Shadow(whl, _, _) => whl.len(),
WhList::Slice(_, bi, ee) => ee - bi,
}
}
fn refer(&'a self, index: usize) -> Option<&'a T> {
match self {
WhList::Single(val) =>
if index == 0 { Some(val) } else { None },
WhList::Vector(vec) =>
vec.get(index),
WhList::Chain(whl, whr) =>
if index >= whl.len() { whr.refer(index) } else { whl.refer(index) },
WhList::Append(whl, val) =>
if index == whl.len() { Some(val) } else { whl.refer(index) },
WhList::Overlay(whl, who) =>
match who.refer(index) {
Some(Some(val)) => Some(val),
_ => whl.refer(index),
},
WhList::Shadow(whl, idx, val) =>
if *idx == index { Some(val) } else { whl.refer(index) },
WhList::Slice(whl, bi, ee) =>
if index >= *ee { None } else { whl.refer(bi + index) },
}
}
fn from_vec(vec: Vec<T>) -> WhList<'a, T> {
WhList::Vector(vec)
}
fn from_single(single: T) -> WhList<'a, T> {
WhList::Single(single)
}
fn modify(&'a self, index: usize, value: T) -> Option<WhList<'a, T>> {
if index >= self.len() {
return None
}
Some(WhList::Shadow(self, index, value))
}
}
fn main() {
let a = WhList::from_vec(vec![1, 2, 3]);
println!("Hello, world!");
}
I guess I'd better not disturb Rust devs if I wrote something seriously wrong .