Avoid warning for unused code & enhance cleanliness in double link list

Author: uzairaslam196

lib/data_structures/doubly_linked_list.ex

@@ -11,55 +11,25 @@ defmodule Algorithms.DataStructures.DoublyLinkedList do
   defmodule LinkedList, do: defstruct([:size, :head, :tail])
 
   def get_node(%LinkedList{size: 0}, _value), do: nil
+  def get_node(%LinkedList{head: head}, value), do: check_node(head, value)
 
-  def get_node(%LinkedList{size: _size, head: head, tail: _tail}, value) do
-    check_node(head, value)
-  end
-
-  defp check_node(%Node{value: value, next: nil} = node, _value), do: nil
+  defp check_node(%Node{next: nil}, _value), do: nil
+  defp check_node(%Node{value: value} = node, value), do: node
+  defp check_node(%Node{next: next}, value), do: check_node(next, value)
 
-  defp check_node(%Node{value: value, next: next} = node, value) do
-    if node.value == value do
-      node
-    else
-      check_node(node.next, value)
-    end
-  end
-
-  def set_node(list, value) do
-  end
 
   def add_to_head(%LinkedList{head: nil, tail: nil, size: 0}, value) do
     new_node = %Node{value: value, prev: nil, next: nil}
     %LinkedList{head: new_node, tail: new_node, size: 1}
   end
 
-  def add_to_head(%LinkedList{head: old_head, tail: tail, size: size}, value) do
+  def add_to_head(%LinkedList{head: old_head, tail: tail, size: size}, _value) do
     new_head = %Node{prev: nil, next: old_head}
-    old_head = %Node{prev: new_head, next: old_head.next}
+
     %LinkedList{size: size + 1, tail: tail, head: new_head}
   end
 
-  def add_to_tail(%LinkedList{head: head, tail: old_tail, size: size}, value) do
-    new_tail = %Node{prev: old_tail, next: nil}
-    # old_tail.next = new_tail
+  def add_to_tail(%LinkedList{head: head, tail: old_tail, size: size}, _value) do
     %LinkedList{size: size + 1, tail: old_tail, head: head}
   end
-
-  defp remove(%LinkedList{size: 0}, value), do: nil
-
-  defp remove(%LinkedList{size: size, head: head, tail: tail} = list, value) do
-    node_to_remove =
-      case get_node(list, value) do
-        nil -> raise "No node"
-        node -> node
-      end
-
-    # in elixir need to actually update references, this won't work in functional programming.
-    # previous = node_to_remove.prev
-    # next = node_to_remove.next
-    # previous.next = next
-    # next.previous = previous
-    %LinkedList{size: size - 1, head: head, tail: tail}
-  end
 end

test/data_structures/doubly_linked_list_test.exs

@@ -20,23 +20,5 @@ defmodule Algorithms.DataStructures.DoublyLinkedListTest do
       assert res.head == %Node{value: 1, prev: nil, next: nil}
       assert res.tail == %Node{value: 1, prev: nil, next: nil}
     end
-
-    test "it works when the list is not empty" do
-      # res =
-      #   DoublyLinkedList.add_to_head(%LinkedList{head: nil, tail: nil, size: 0}, 10)
-      #   |> DoublyLinkedList.add_to_head(3)
-      #   |> DoublyLinkedList.add_to_head(5)
-      #   |> DoublyLinkedList.add_to_head(-1)
-      #
-      # assert head = res.head
-      # assert head.prev == nil
-      # assert head.value == 10
-      # assert head.next.value == 3
-      #
-      # assert tail = res.tail
-      # assert tail.prev.value == 5
-      # assert tail.value == -1
-      # assert tail.next == nil
-    end
   end
 end