Advent of Code 2024 - Day 19

I have never written a macro before, but part one inspired me to give it a go. In hindsight, it was a bad idea, but it worked for part one.

defmodule LinenLayout do
  defmacro __using__(_opts) do
    quote do
      import LinenLayout

      # safeq (resp. safer) is needed, because I wanted a clause like:
     # def q(_), do: 0
     # but Idk how to make sure that clause comes _after_ all the def's
     # that would be expanded from macros, so instead I use try/rescue to
     # catch invocations that don't have matching defs (e.g., patterns s.t. no
     # towel exists for.
      def safeq(x) do
        try do
          q(x)
        rescue _ -> nil
        end
      end
  
      def safer(x) do
        try do
          r(x)
        rescue _ -> nil
        end
      end

      # these two stop the recursive steps below
      def qq(nil) do
        0
      end
      # using `raise` for control flow. I don't like it, but I was desperate
      # will be rescued in `count_makeable`
      def qq(1) do
        raise "yes"
      end
      
      def qq(x) do
          (safeq(x) |> qq()) + (safer(x) |> qq())
      end

      # invoked when there is no pattern left - we had all the towels we needed
      def q(""), do: 1
      def r(""), do: 1
      def count_makeable(towels) do
        towels 
        |> String.split("\n", trim: true)
        |> Stream.map(&
          try do
            qq(&1)
          # qq throws when `safeq` (resp. `safer`) finished completing a patttern
          rescue _ in RuntimeError -> 1
          end) 
        |> Enum.sum()
      end
    end
  end

  # I didn't need `f` _and_ `h`, but I wanted
  # the macro to expand out to functions with different names.
  # there is a way to do this as an arg to the macro, but  i was lazy.
  # these are exactly the same, to understand why they exist, read `g/1`
  # 
  # The basic idea of the approach is that we will use Elixir's binary
  # pattern matching to do all of the work. Each towel in our
  # inventory will get its own `def q(color <> rest)`. We will recursively call on `q(rest)` 
  # until either:
  # (a) We exhaust the pattern (yay, we had all the towels we needed!) 
  # (b) we throw an error for no clause matching input params (the pattern began 
  # with color  we don't have a towel for).
  defmacro f(i) do
    quote do
      def q(unquote(i) <> rest), do: rest
    end
  end
  
 defmacro h(i) do
    quote do
      def r(unquote(i) <> rest), do: rest
    end
  end

  # takes a list of towels and expands out to two sets of functions:
  # one set where the clauses are ordered longest towel first, e.g.,
  # if `bgr` and `b` are both towels `q("bgr" <> rest)` will appear before
  # `q("b" <> rest)`.
  # the other set is reversed - these are the `r` functions, expanded from `h`, above.
  # 
  # why did I do this? because just one of these directions will miss some patterns
 # because they will be greedy in either using the towels with more stripes first or
 # using the towels with the least stripes first. Doing both was my attempt to fix the
 # issue where either of these under counted. This doesn't _really_ fix the real issue.
 # There could be a towel `"bg"` that is "between" `"bgr"` and `"b"` that would never be
# accounted for if the pattern began with `"bgr"`. In fact, this exact issue is probably why
# this approach will not work for pt. 2.
  defmacro g(u) do
   # `u` is the list of towels we have 
   u = u
    |> String.split(", ")
    

   # expand out `f` for all the towels
    (u 
      |> Enum.sort_by(fn l -> -String.length(l) end) 
      |> Enum.map(fn o ->
        quote do
          f(unquote(o))
        end  
        end)
    )
    ++
    (
     # then expand out `h`
      u 
      |> Enum.sort_by(&(String.length(&1))) 
      |> Enum.map(&(quote do h(unquote(&1)) end))
    )
  end
end

Now actually solving part 1:

defmodule Foo do
  use LinenLayout

  g "r, wr, b, g, bwu, rb, gb, br"
end

"""
brwrr
bggr
gbbr
rrbgbr
ubwu
bwurrg
brgr
bbrgwb
"""
|> Foo.count_makeable()