Funny pipe code

1. How can I avoid using the temp var edges (i.e. use a continuous pipe)

# ...
|> Map.get("edges")
|> case do
  [] -> :ok
  edges ->
    edges
    |> Enum.at(-1)
    # get last edge cursor
    |> Map.get("cursor")
    |> IO.inspect
    # recurse to get next page
    |> get(pagenum + 1)
    :ok
  end
# ...

But I’d probably want to refactor what you have to something like

def handle_resp(status_code, raw_body)

def handle_resp(200, raw_body) do
  raw_body
  |> Posion.decode!()
  |> extract_edges!()
  |> handle_edges()
end

defp extract_edges!(%{"data" => %{"repository" => %{"issues" => %{"edges" => edges}}}}) do
  edges
end

defp extract_edges!(invalid_body) do
  raise("invalid body: #{inspect(invalid_body)}")
end

defp handle_edges([]), do: :ok
defp handle_edges(edges) when is_list(edges) do
  # not sure what this is supposed to do
  # ...
  :ok
end

# etc

Extract to another function.

edges =
  try
    body
    |> Poison.Parser.parse!()
    |> Map.get("data")
    |> Map.get("repository")
    |> Map.get("issues")
    |> Map.get("edges")
    |> case do
      edges when map_size(edges) == 0 -> throw(:ok)
      edges -> edges
    end
    |> Enum.at(-1)
    |> Map.get("cursor")
    |> IO.inspect
    |> get(pagenum + 1)
    throw(:ok)
  catch
    value -> value
  end

Please note, Kernel.catch/1 is a local return.

But I probably would better extract it into a private function.

I’d change that to:

get_in(~w<data repository issues edges>)

C’mon, I blindly copy-pasted it

You know that if you want a harsh critic you must hire a Slav!

Appreciate your help here. Just trying to make you into a Superman.

I’m Russian, I know it better than anybody else

Thanks a million guys!
Working on your pointers.
Any thoughts about question 2 (tee operator) ?
Something like:

data |> transformation_1 |> transformation_2 T> snapshot_data |> transformation_3
snapshot_data |> transformation_4

def f_1(data) do
  data
  |> transformation_1()
  |> transformation_2()
  |> f_2()
end

# still purely sequential - more like a (sequential) fork/join
# because everything has to be an expression.
#
def f_2(snapshot_data) do
  {transformation_3(snapshot_data),transformation_4(snapshot_data)} # return both results as a tuple
end

More often than not the solution to a problem is “functions”.

Typically a “local return” is simply returning a value - which is what all functions naturally do. And even though it says throw you are essentially using it as a goto - i.e. tread carefully.

The primary intent behind a throw is a non-local return of a value as described in Try a try in a tree.

Aside return vs throw vs exit vs raise.