pelemay v0.0.12 SumMag

SumMag: a meta-programming library for Pelemay and Cockatorice.

Link to this section Summary

Functions

## Examples

Find a specified fucntion from ast

Find specified fucntions from ast

## Examples

"defmacro do" take the following code.

## Examples
iex> quote do end |> SumMag.parse(%{target: :pelemay})
[]

iex> (quote do: def func(a), do: a) |> SumMag.parse(%{target: :pelemay})
[[function_name: :func, is_public: true, args: [:a], do: [{:a, [], SumMagTest}], is_nif: false ]]

iex> (quote do
...>    def func(list) do
...>      list
...>      |> Enum.map(& &1)
...>    end
...> end) |> SumMag.parse(%{target: :pelemay})
[[function_name: :func, is_public: true, args: [:list], do: [{:|>, [context: SumMagTest, import: Kernel], [{:list, [], SumMagTest}, {{:., [], [{:__aliases__, [alias: false], [:Enum]}, :map]}, [], [{:&, [], [{:&, [], [1]}]}]}]}], is_nif: false ]]

## Examples

## Examples

Same behaviour to "|>"

Find captured variable in the anonymous function.

Link to this section Types

Link to this section Functions

Link to this function

concat_name_nif(name, env)

## Examples

iex> :func |> SumMag.concat_name_nif(%{}) :func_nif

Link to this function

concat_name_num(name, map)

## Examples

iex> :func |> SumMag.concat_name_num(%{num: 1}) :func_1

iex> :fl |> SumMag.concat_name_num(%{num: 2}) :fl_2

Link to this function

concat_name_stub(name, env)

## Examples

iex> :pelemay |> SumMag.concat_name_stub(%{}) :pelemaystub

Link to this function

convert_args(arg_list, env)

## Examples

iex> [] |> SumMag.convert_args(%{}) []

iex> [{:a, [], Elixir}] |> SumMag.convert_args(%{}) [:a]

iex> [{:a, [], Elixir}, {:b, [], Elixir}] |> SumMag.convert_args(%{}) [:a, :b]

Link to this function

func_with_num(kl, env)

## Examples

iex> SumMag.func_with_num([function_name: :func], %{num: 1}) [function_name: :func_1]

Link to this function

get_func_info(map)

## Examples

iex> SumMag.get_func_info(%{nif: [function_name: :func]}) [function_name: :func]

Link to this function

iced_block(funcs)

Link to this function

include_specified_func?(ast_term, module, arg)

include_specified_func?(Macro.input(), atom(), {atom(), number()}) :: boolean()

Find a specified fucntion from ast

iex> quote do
...> [1, 2]
...> |> Enum.map(&(&1 + 1))
...> |> Enum.map(&(&1 + 2))
...> end |>
...> SumMag.include_specified_func?(:Enum, {:map, 2})
true
Link to this function

include_specified_functions(ast_term, module_functions)

Link to this function

include_specified_functions?(ast_term, list)

include_specified_functions?(Macro.input(), [{atom(), list()}]) :: [...]

Find specified fucntions from ast

iex> quote do
...> [1, 2]
...> |> Enum.map(&(&1 + 1))
...> |> Enum.map(&(&1 + 2))
...> end |>
...> SumMag.include_specified_functions?([Enum: [map: 2, zip: 2]])
[map: 2]
Link to this function

increment_nif(map)

## Examples

iex> SumMag.increment_nif(%{num: 0}) 1

iex> SumMag.increment_nif(%{num: 1}) 2

Link to this function

melt_block(other)

"defmacro do" take the following code.

If you define a function:

[ 
  do: {def, _line, [
    { :name, _line, arg },
    [
      do: main_process
    ]}
]

If you define functions:

[ 
  do: {:__block__, [], [
    {def, _line, [{ :name, _line, arg },do: main_process
    ]}
]
  iex> quote do  
  ...>   def func do: "doctest"    
  ...> end  
  {:def, [context: SumMagTest, import: Kernel],
    [{:func, [context: SumMagTest], [[do: "doctest"]]}]}

  iiex> quote do
  ...>   defmmf do
  ...>     def func do: "doctest"
  ...>   end
  ...> end 
Link to this function

merge_func_info(env, keyword)

## Examples

iex> SumMag.merge_func_info(%{nif: [function_name: :func]}, [is_public: true]) %{nif: [function_name: :func, is_public: true]}

Link to this function

parse(arg, env)

## Examples
iex> quote do end |> SumMag.parse(%{target: :pelemay})
[]

iex> (quote do: def func(a), do: a) |> SumMag.parse(%{target: :pelemay})
[[function_name: :func, is_public: true, args: [:a], do: [{:a, [], SumMagTest}], is_nif: false ]]

iex> (quote do
...>    def func(list) do
...>      list
...>      |> Enum.map(& &1)
...>    end
...> end) |> SumMag.parse(%{target: :pelemay})
[[function_name: :func, is_public: true, args: [:list], do: [{:|>, [context: SumMagTest, import: Kernel], [{:list, [], SumMagTest}, {{:., [], [{:__aliases__, [alias: false], [:Enum]}, :map]}, [], [{:&, [], [{:&, [], [1]}]}]}]}], is_nif: false ]]
Link to this function

parse_args(body, env)

## Examples

iex> [{:null, [context: Elixir], []}, [do: {:nil, [], Elixir}]] |> SumMag.parse_args(%{}) []

iex> [{:func, [context: Elixir], [{:a, [], Elixir}]}, [do: {:a, [], Elixir}]] |> SumMag.parse_args(%{}) [:a]

iex> [{:add, [context: Elixir], [{:a, [], Elixir}, {:b, [], Elixir}]},[do: {:+, [context: Elixir, import: Kernel], [{:a, [], Elixir}, {:b, [], Elixir}]}]] |> SumMag.parse_args(%{}) [:a, :b]

Link to this function

parse_do(body, env)

## Examples

iex> [{:null, [context: Elixir], []}, [do: {:nil, [], Elixir}]] |> SumMag.parse_do(%{}) [{:nil, [], Elixir}]

iex> [{:func, [context: Elixir], [{:a, [], Elixir}]}, [do: {:a, [], Elixir}]] |> SumMag.parse_do(%{}) [{:a, [], Elixir}]

iex> [{:add, [context: Elixir], [{:a, [], Elixir}, {:b, [], Elixir}]},[do: {:+, [context: Elixir, import: Kernel], [{:a, [], Elixir}, {:b, [], Elixir}]}]] |> SumMag.parse_do(%{}) [{:+, [context: Elixir, import: Kernel], [{:a, [], Elixir}, {:b, [], Elixir}]}]

Link to this function

parse_function_name(body, env)

## Examples

iex> [{:null, [context: Elixir], []}, [do: {:nil, [], Elixir}]] |> SumMag.parse_function_name(%{}) :null

iex> [{:func, [context: Elixir], [{:a, [], Elixir}]}, [do: {:a, [], Elixir}]] |> SumMag.parse_function_name(%{}) :func

iex> [{:add, [context: Elixir], [{:a, [], Elixir}, {:b, [], Elixir}]},[do: {:+, [context: Elixir, import: Kernel], [{:a, [], Elixir}, {:b, [], Elixir}]}]] |> SumMag.parse_function_name(%{}) :add

Link to this function

pipe(unpipe_list)

Same behaviour to "|>"

Link to this function

quoted_var?(arg1)

Find captured variable in the anonymous function.

Link to this function

quoted_vars?(left, right)