Incorrect series elements for {:list, :category} #1085

    test "create series for all types" do
      forall_types(fn t ->
        list = 0..3 |> Enum.map(fn _ -> value(t) end)
        s = list |> Series.from_list(dtype: t)
        #IO.puts("type #{inspect t} list: #{inspect list} value #{inspect s}")
        try do
          assert Series.dtype(s) == t
          assert Series.to_list(s) == list
        rescue err ->
          IO.puts("error in \ntype: #{inspect t}\nlist: #{inspect list}\nseries: #{inspect s}\nerror: #{Exception.format(:error, err, __STACKTRACE__)}")
          raise err
        end
      end)
    end

    defp forall_types(fun) do
      types = [
        :null, :binary, :boolean, :category, :date, :time, :string, {:f, 64}, {:decimal, 10, 1}, # {:f, 32},
        {:naive_datetime, :microsecond}, # {:duration, :microsecond} # {:datetime, :microsecond, "UTC"},
      ] ++ (for signed <- [:s, :u], size <- [8, 16, 32, 64], do: {signed, size})
      types = types
        ++ (for t <- types, do: {:list, t})
        ++ (for t <- types, do: {:struct, [{"a", t}]})
      types = types
        ++ (for t <- types, do: {:list, t})
        ++ (for t <- types, do: {:struct, [{"a", t}]})
      types = types
        ++ (for t <- types, do: {:list, t})
        ++ (for t <- types, do: {:struct, [{"a", t}]})
      for t <- types do
        fun.(t)
      end
    end

    defp value(:null), do: nil
    defp value(:binary), do: Enum.random(["ba", "bb"])
    defp value(:boolean), do: Enum.random([true, false])
    defp value(:category), do: Enum.random(["ca", "cb"])
    defp value(:date), do: Enum.random([~D[2000-01-01], ~D[2001-01-01]])
    defp value(:time), do: Enum.random([~T[00:00:00.000000], ~T[01:01:01.000000]])
    defp value(:string), do: Enum.random(["sa", "sb"])
    defp value({:decimal, _, _}), do: Enum.random([Decimal.new("1.3"), Decimal.new("2.3")])
    defp value({:naive_datetime, :microsecond}), do: Enum.random([~N[2000-01-01 00:00:00.000000], ~N[2001-01-01 00:00:00.000000]])
    defp value({:datetime, :microsecond, "UTC"}), do: Enum.random([~U[2000-01-01 00:00:00.000000Z], ~U[2001-01-01 00:00:00.000000Z]])
    defp value({:duration, :microsecond}), do: Enum.random([0, 1246421])
    defp value({:f, _}), do: Enum.random([1.0, 0.1])
    defp value({:s, _}), do: Enum.random([1, -1])
    defp value({:u, _}), do: Enum.random([1, 2])
    defp value({:list, t}), do: [value(t)]
    defp value({:struct, ts}), do: Enum.map(ts, fn {k, t} -> {k, value(t)} end) |> Enum.into(%{})