wip

Author: mat-hek

misc/language-tour-guide/elixir_tour/lib/elixir_tour.ex

@@ -1,15 +1,17 @@
 defmodule ElixirTour do
   use GenServer
+
   import Popcorn.Wasm, only: [is_wasm_message: 1]
+
+  alias ElixirTour.Evaluator
   alias Popcorn.Wasm
 
   @process_name :main
 
   @type editor_id :: String.t()
-  @type bindings :: Keyword.t()
   @type state :: %{
           editor_order: [editor_id()],
-          bindings: %{editor_id() => bindings()}
+          bindings: %{editor_id() => Evaluator.bindings()}
         }
   @type wasm_result :: {:resolve, String.t(), state()} | {:reject, String.t(), state()}
 
@@ -21,7 +23,7 @@ defmodule ElixirTour do
   def init(_init_arg) do
     Wasm.register(@process_name)
     :application.set_env(:elixir, :ansi_enabled, false)
-    {:ok, %{editor_order: [], bindings: %{}}}
+    {:ok, %{editor_order: [], bindings: %{}, evaluator: Evaluator.start!()}}
   end
 
   @impl GenServer
@@ -38,37 +40,30 @@ defmodule ElixirTour do
   end
 
   @spec handle_wasm({:wasm_call, list()}, state()) :: wasm_result()
-  defp handle_wasm({:wasm_call, ["set_editor_order", editor_order]}, _state) do
-    {:resolve, "ok", %{editor_order: editor_order, bindings: %{}}}
+  defp handle_wasm({:wasm_call, ["set_editor_order", editor_order]}, state) do
+    {:resolve, "ok", %{state | editor_order: editor_order, bindings: %{}}}
   end
 
   defp handle_wasm({:wasm_call, ["eval_elixir", editor_id, code]}, state) do
-    editor_order = Map.get(state, :editor_order, [])
-    bindings_map = Map.get(state, :bindings, %{})
+    %{evaluator: evaluator, bindings: bindings_map} = state
 
-    preceding_editor_ids = get_preceding_editors(editor_order, editor_id)
+    preceding_editor_ids = get_preceding_editors(state.editor_order, editor_id)
 
     preceding_bindings =
       preceding_editor_ids
       |> Enum.map(&Map.get(bindings_map, &1, []))
       |> Enum.reduce([], &Keyword.merge(&2, &1))
 
-    try do
-      case eval(code, preceding_bindings) do
-        {:ok, result, new_bindings} ->
-          editor_bindings = get_changed(preceding_bindings, new_bindings)
-          updated_bindings = Map.put(bindings_map, editor_id, editor_bindings)
-
-          {:resolve, inspect(result), %{state | bindings: updated_bindings}}
+    case Evaluator.eval(state.evaluator, code, preceding_bindings) do
+      {:ok, result, new_bindings} ->
+        editor_bindings = get_changed(preceding_bindings, new_bindings)
+        updated_bindings = Map.put(bindings_map, editor_id, editor_bindings)
 
-        {:error, error_message} ->
-          {:reject, error_message, state}
-      end
-    rescue
-      e ->
-        error_message = Exception.format(:error, e)
+        {:resolve, inspect(result), %{state | bindings: updated_bindings}}
 
-        {:reject, error_message, state}
+      {:error, error_message} ->
+        evaluator = if Process.alive?(state.evaluator), do: evaluator, else: Evaluator.start!()
+        {:reject, error_message, %{state | evaluator: evaluator}}
     end
   end
 
@@ -77,31 +72,12 @@ defmodule ElixirTour do
     Enum.take_while(editor_order, &(&1 != editor_id))
   end
 
-  @spec get_changed(bindings(), bindings()) :: bindings()
+  @spec get_changed(Evaluator.bindings(), Evaluator.bindings()) :: Evaluator.bindings()
   defp get_changed(base_kw, new_kw) do
     unchanged? = fn {key, value} ->
       Keyword.get(base_kw, key) == value
     end
 
     Enum.reject(new_kw, unchanged?)
   end
-
-  @spec eval(String.t(), bindings()) :: {:ok, any(), bindings()} | {:error, String.t()}
-  defp eval(code, bindings) do
-    try do
-      {evaluated, new_bindings} =
-        Code.eval_string(code, bindings, %Macro.Env{
-          __ENV__
-          | file: "playground",
-            line: 1,
-            module: nil
-        })
-
-      {:ok, evaluated, new_bindings}
-    rescue
-      e ->
-        error_message = Exception.format(:error, e)
-        {:error, error_message}
-    end
-  end
 end

misc/language-tour-guide/elixir_tour/lib/elixir_tour/evaluator.ex

@@ -0,0 +1,45 @@
+defmodule ElixirTour.Evaluator do
+  use GenServer
+
+  @type bindings :: Keyword.t()
+
+  @spec start!() :: pid()
+  def start!() do
+    {:ok, pid} = GenServer.start(__MODULE__, [])
+    pid
+  end
+
+  @spec eval(pid(), String.t(), bindings()) ::
+          {:ok, result :: any(), bindings()} | {:error, message :: String.t()}
+  def eval(runner, code, bindings) do
+    try do
+      GenServer.call(runner, {:eval, code, bindings}, :infinity)
+    catch
+      :exit, _reason -> {:error, "error"}
+    end
+  end
+
+  @impl true
+  def init(_opts) do
+    {:ok, %{}}
+  end
+
+  @impl true
+  def handle_call({:eval, code, bindings}, _from, state) do
+    try do
+      {result, new_bindings} =
+        Code.eval_string(code, bindings, %Macro.Env{
+          __ENV__
+          | file: "playground",
+            line: 1,
+            module: nil
+        })
+
+      {:reply, {:ok, result, new_bindings}, state}
+    rescue
+      error ->
+        error_message = Exception.format(:error, error)
+        {:reply, {:error, error_message}, state}
+    end
+  end
+end

misc/language-tour-guide/src/content/8-processes/links.livemd

@@ -0,0 +1,7 @@
+# Links
+
+```elixir
+{:ok, a} = Agent.start_link(fn -> %{} end)
+
+Agent.get(a, fn _s -> raise "dupa" end)
+```

misc/language-tour-guide/src/content/8-processes/message_passing.livemd

@@ -47,10 +47,10 @@ send(self(), {:hello, "world"})
 
 receive do
   x when is_integer(x) ->
-    IO.inspect x, label: "This won't match"
+    "Received an integer: #{x}"
 
   {:hello, addressee} ->
-    IO.inspect addressee, label: "Received hello to"
+    "Received hello to: #{addressee}"
 end
 ```
 
@@ -62,9 +62,9 @@ send(self(), :bye)
 
 receive do
   {:hello, addressee} ->
-    IO.inspect addressee, label: "This won't be received"
+    "Received hello to: #{addressee}"
 after
-  1_000 -> "Nothing after 1s"
+  100 -> "Nothing after 100 milliseconds"
 end
 ```
 

misc/language-tour-guide/src/utils/content/configuration.ts

@@ -163,6 +163,10 @@ export const navigationConfig: NavigationConfig = [
       {
         name: "Message passing",
         component: lazyLoadLiveMd("8-processes/message_passing")
+      },
+      {
+        name: "Links",
+        component: lazyLoadLiveMd("8-processes/links")
       }
     ]
   },

patches/otp/stdlib/gen_server.erl

@@ -0,0 +1,19 @@
+-module(gen_server).
+
+-compile({popcorn_patch_private, client_stacktrace/1}).
+
+client_stacktrace(undefined) ->
+    undefined;
+client_stacktrace({From, _Tag}) ->
+    client_stacktrace(From);
+client_stacktrace(From) when is_pid(From), node(From) =:= node() ->
+    case process_info(From, registered_name) of
+        undefined ->
+            {From, dead};
+        [] ->
+            {From, {From, []}};
+        {registered_name, Name} ->
+            {From, {Name, []}}
+    end;
+client_stacktrace(From) when is_pid(From) ->
+    {From, remote}.