pub struct List[T] {
mut:
	head ?&Node[T]
	size int
}

pub fn (mut l List[T]) prepend(mut node Node[T]) {
	if head := l.head {
		node.next = head
		l.head = &node
		l.size = l.size + 1
	} else {
		l.size = 1
		l.head = &node
	}
}

pub fn (mut l List[T]) append(mut node Node[T]) ?int {
	if h := l.head {
		_ := h
	} else {
		l.head = &node
		l.size = 0
		return l.size
	}

	mut curr_node := l.head
	for {
		if mut curr_node != none {
			if next_node := curr_node.next {
				curr_node = next_node
			} else {
				curr_node.next = &node
				l.size = l.size + 1
				break
			}
		}
	}
	return l.size
}

pub fn (mut l List[T]) find_last(node ?&Node[T]) ?&Node[T] {
	if next := node?.next {
		return l.find_last(next)
	} else {
		return node
	}
}

@[heap]
pub struct Node[T] {
mut:
	data T
	next ?&Node[T]
}

fn test_main() {
	mut list := List[string]{}
	list.prepend(mut Node{ data: 'zero' })
	list.prepend(mut Node{ data: 'first' })
	list.append(mut Node{ data: 'last' }) or { panic('unable to append linked list') }
	list.append(mut Node{ data: 'very last' }) or { panic('unable to append linked list') }

	assert list.find_last(list.head)? == Node{
		data: 'very last'
	}
	assert list.head?.next?.next?.next? == Node{
		data: 'very last'
	}
}