Brute force solution to try different possibilities simultaneously for the sublist challenge on excercism.io

sublist.exs

defmodule Sublist do
  @doc """
  Returns whether the first list is a sublist or a superlist of the second list
  and if not whether it is equal or unequal to the second list.
  """
  def compare(a, b) do
  	task1 = Task.async(fn -> is_equal(a, b) end)
  	task2 = Task.async(fn -> 
                          case is_equal(a, b) do
                            :equal ->
                              :equal
                            :fail ->
                              is_sublist(a, b, Enum.count(a)) 
                          end
                        end)
    task3 = Task.async(fn -> 
                          case is_equal(a, b) do
                            :equal ->
                              :equal
                            :fail ->
                              is_sublist(Enum.reverse(a), Enum.reverse(b), Enum.count(a)) 
                          end
                        end)
  	task4 = Task.async(fn -> 
                          case is_equal(a, b) do
                            :equal ->
                              :equal
                            :fail ->
                              is_superlist(a, b, Enum.count(b)) 
                          end
                        end)
    task5 = Task.async(fn -> 
                          case is_equal(a, b) do
                            :equal ->
                              :equal
                            :fail ->
                              is_superlist(Enum.reverse(a), Enum.reverse(b), Enum.count(b)) 
                          end
                        end)
    await([task1, task2, task3, task4, task5])
  end

  def is_equal(a, b) do
    if(a === b) do
      :equal
    else
      :fail
    end
  end

  def is_sublist(_a, [], _c) do
    :fail
  end

  def is_sublist(a, [ head | tail], c) do
    case is_equal(a, Enum.take([head | tail], c)) do
      :equal ->
        :sublist
      :fail ->
        if Enum.count(tail) < c do
          :fail
        else         
          is_sublist(a, tail, c)
        end
    end
  end

  def is_superlist(a, b, c) do
    case is_sublist(b, a, c) do
      :sublist ->
        :superlist
      :fail ->
        :fail
    end
  end

  def await([]) do
    :unequal
  end

  def await(tasks) do
    receive do
      message ->
        case Task.find(tasks, message) do
          {:fail, task} ->
            await(List.delete(tasks, task))
          {reply, _task} ->
            reply       
          nil ->
            await(tasks)
        end
    end
  end

end