kmx.io/pure/lib/pure.ex

Branch - branch -master

• Show log

  Commit

• Hash : 1533add8
  Author : Thomas de Grivel
  Date : 2022-02-18T10:08:21
  

  VARIABLES
  

Download

• lib/pure.ex

• defmodule Pure do
    @moduledoc """
    Documentation for `Pure`.
    """
  
    @doc """
    Checks if string is a valid guard expression.
  
    ## Examples
  
        iex> i = 0
        iex> Pure.string_is_guard?("i == 1", __ENV__)
        true
    """
    def string_is_guard?(str, env) when is_binary(str) do
      {:ok, quoted} = Code.string_to_quoted(str)
      is_guard?(quoted, env)
    end
  
    @doc """
    Checks if quoted expression is a valid guard expression.
  
    ## Examples
  
        iex> i = 0
        iex> Pure.is_guard?(quote do i == 1 end, __ENV__)
        true
    """
      def is_guard?(quoted, env) do
      {erl, _, _, _env} = :elixir.quoted_to_erl(quoted, env)
      result = :erl_lint.is_guard_test(erl)
      IO.inspect([:is_guard?, quoted, result])
      result
    end
  
    @doc """
    Checks if string is a pattern expression.
  
    ## Examples
  
        iex> Pure.string_is_pattern?("{a, b}", __ENV__)
        true
    """
    def string_is_pattern?(str, env) when is_binary(str) do
      {:ok, quoted} = Code.string_to_quoted("#{str} = nil")
      is_match?(quoted, env)
    end
  
    @doc """
    Checks if string is a match expression.
  
    ## Examples
  
        iex> Pure.string_is_match?("{a, b} = {1, 2}", __ENV__)
        true
    """
    def string_is_match?(str, env) when is_binary(str) do
      {:ok, quoted} = Code.string_to_quoted(str)
      is_match?(quoted, env)
    end    
  
    @doc """
    Checks if quoted expression is a match expression.
  
    ## Examples
  
        iex> Pure.is_match?(quote do {a, b} = nil end, __ENV__)
        true
    """
    def is_match?(quoted, env) do
      {erl, _, _, _env} = :elixir.quoted_to_erl(quoted, env)
      #IO.inspect(erl)
      case erl do
        {:match, _, a, b} ->
          a_is_pattern? = :pure.is_pattern_expr(a)
          b_is_guard? = :erl_lint.is_guard_test(b)
          result = a_is_pattern? && b_is_guard?
          IO.inspect([:is_match?, quoted,
                      a: a, is_pattern?: a_is_pattern?,
                      b: b, is_guard?: b_is_guard?,
                      result: result])
          result
        _ ->
          IO.inspect([:is_match?, quoted, false])
          false
      end
    end    
  
    def is_pure?(quoted = {:__block__, _, block}, env) do
      is_pure_block?(quoted, env, block, [])
    end
    def is_pure?(quoted, env) do
      result = is_guard?(quoted, env) || is_match?(quoted, env)
      IO.inspect([:is_pure?, quoted, result])
      result
    end
  
    def is_pure_block?(quoted, _env, [], _acc) do
      IO.inspect([:is_pure?, quoted, true])
      true
    end
    def is_pure_block?(quoted, env, [first | rest], acc) do
      env = env_eval(env, {:__block__, 1, Enum.reverse(acc)})
      if is_pure?(first, env) do
        is_pure_block?(quoted, env, rest, [first | acc])
      else
        IO.inspect([:is_pure?, quoted, false])
        false
      end
    end
  
    def env_eval(env, quoted) do
      IO.inspect([:env_eval, quoted])
      {env1, _} = Code.eval_quoted(quote do unquote(quoted); __ENV__ end, [], env)
      env1
    end
  
    defmacro eval(str) when is_binary(str) do
      {:ok, q} = Code.string_to_quoted(str)
      quote do
        require Pure
        Pure.eval(unquote(q))
      end
    end
    defmacro eval(q) do
      if is_pure?(q, __ENV__) do
        q
      else
        raise ArgumentError, "not a pure expression: #{Macro.to_string(q)}"
      end
    end
  end
  

Download