Linked lists

class Node:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next


class LinkedList:
    def __init__(self):
        self.head = None

    def prepend(self, value):
        self.head = Node(value, self.head)

    def append(self, value):
        node = Node(value)
        if self.head is None:
            self.head = node
            return
        cur = self.head
        while cur.next is not None:
            cur = cur.next
        cur.next = node

    def remove(self, value):
        prev, cur = None, self.head
        while cur is not None and cur.value != value:
            prev, cur = cur, cur.next
        if cur is None:
            return False
        if prev is None:
            self.head = cur.next
        else:
            prev.next = cur.next
        return True

class Node {
  constructor(value, next = null) {
    this.value = value;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  prepend(value) {
    this.head = new Node(value, this.head);
  }

  append(value) {
    const node = new Node(value);
    if (this.head === null) {
      this.head = node;
      return;
    }
    let cur = this.head;
    while (cur.next !== null) {
      cur = cur.next;
    }
    cur.next = node;
  }

  remove(value) {
    let prev = null;
    let cur = this.head;
    while (cur !== null && cur.value !== value) {
      prev = cur;
      cur = cur.next;
    }
    if (cur === null) return false;
    if (prev === null) {
      this.head = cur.next;
    } else {
      prev.next = cur.next;
    }
    return true;
  }
}

type Node struct {
	Value int
	Next  *Node
}

type LinkedList struct {
	Head *Node
}

func (l *LinkedList) Prepend(value int) {
	l.Head = &Node{Value: value, Next: l.Head}
}

func (l *LinkedList) Append(value int) {
	node := &Node{Value: value}
	if l.Head == nil {
		l.Head = node
		return
	}
	cur := l.Head
	for cur.Next != nil {
		cur = cur.Next
	}
	cur.Next = node
}

func (l *LinkedList) Remove(value int) bool {
	var prev *Node
	cur := l.Head
	for cur != nil && cur.Value != value {
		prev, cur = cur, cur.Next
	}
	if cur == nil {
		return false
	}
	if prev == nil {
		l.Head = cur.Next
	} else {
		prev.Next = cur.Next
	}
	return true
}

struct Node {
    value: i32,
    next: Option<Box<Node>>,
}

struct LinkedList {
    head: Option<Box<Node>>,
}

impl LinkedList {
    fn prepend(&mut self, value: i32) {
        self.head = Some(Box::new(Node { value, next: self.head.take() }));
    }

    fn append(&mut self, value: i32) {
        let node = Box::new(Node { value, next: None });
        if self.head.is_none() {
            self.head = Some(node);
            return;
        }
        let mut cur = self.head.as_mut().unwrap();
        while cur.next.is_some() {
            cur = cur.next.as_mut().unwrap();
        }
        cur.next = Some(node);
    }

    fn remove(&mut self, value: i32) -> bool {
        // `link` is the pointer to change: the head, or some node's next.
        let mut link = &mut self.head;
        while link.as_ref().map_or(false, |n| n.value != value) {
            link = &mut link.as_mut().unwrap().next;
        }
        match link.take() {
            None => false,
            Some(node) => {
                *link = node.next;
                true
            }
        }
    }
}