{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metaprogramming & macros\n",
    "\n",
    "Julia represents its own code as a data structure accessible from the language itself. Since code is represented by objects that can be created and manipulated from within the language, it is possible for a program to transform and generate its own code, that is to create powerful macros (the term \"metaprogramming\" refers to the possibility to write code that write codes that is then evaluated).\n",
    "\n",
    "Note the difference with C or C++ macros. There, macros work performing textual manipulation and substitution before any actual parsing or interpretation occurs.\n",
    "\n",
    "In Julia, macros works when the code has been already parsed and organised in a syntax tree, and hence the semantic is much richer and allows for much more powerful manipulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Macros in C++ (example from FFSM++)\n",
    "#=\n",
    "\n",
    "#define CONSTRAIN_START_LOOP(pVector,cn) \\\n",
    "  for (uint r1=0;r1<l2r.size();r1++){ \\\n",
    "    for (uint r2=0;r2<l2r[r1].size();r2++){ \\\n",
    "      for (uint p=0;p<(pVector).size();p++){ \\\n",
    "        int psec = p+nPriPr; \\\n",
    "        cix = gix((cn), r1, r2, p);\n",
    "#define CONSTRAIN_END_LOOP \\\n",
    "  }}}\n",
    "\n",
    "# using the macro to avoid writing the multiple loop every time..\n",
    "    \n",
    "// mkteq2(i,p_tr)..  RVAR('dl',i,p_tr)+sum(j,EXP(i,j,p_tr))  =e=  RVAR('sl',i,p_tr)+ sum(b,EXP(b,i,p_tr)); // h1\n",
    "CONSTRAIN_START_LOOP(secPr, 0) // attenction! you have to give the same order number as you inserted in the cons vector\n",
    "  g[cix] = x[gix(\"dl\",r1,r2,psec)]-x[gix(\"sl\",r1,r2,psec)];\n",
    "  for (uint r2To=0;r2To<l2r[r1].size();r2To++){\n",
    "    g[cix] += x[gix(\"rt\",r1,r2,psec,r2To)]-x[gix(\"rt\",r1,r2To,psec,r2)];\n",
    "  }\n",
    "CONSTRAIN_END_LOOP    \n",
    "=#\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manually create expressions in Julia\n",
    "You can create and save unevaluated expressions using either:\n",
    " - :(expr)\n",
    " - quote expr end\n",
    " - parse(\"expr\")\n",
    " - Expr(expr_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":(1 + 2 * 3)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myexpr1 = :(1+2*3) # save the `1+2*3` expression in the `myexpr1` expression\n",
    "myexpr2 = quote 1+2*3 end\n",
    "myexpr3 = Meta.parse(\"1+2*3\")\n",
    "myexpr4 = Expr(:call, :+, 1, Expr(:call, :*, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Such expressions can then be evaluated in a second moment:\n",
    "eval(myexpr1) # here the expression is evaluated and the code returns 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expr\n",
      "  head: Symbol call\n",
      "  args: Array{Any}((3,))\n",
      "    1: Symbol +\n",
      "    2: Int64 1\n",
      "    3: Expr\n",
      "      head: Symbol call\n",
      "      args: Array{Any}((3,))\n",
      "        1: Symbol *\n",
      "        2: Int64 2\n",
      "        3: Int64 3\n"
     ]
    }
   ],
   "source": [
    "dump(myexpr4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@unless (macro with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Macros in Julia\n",
    "# Macros in Julia take one or more input expressions and return a modified expressions (at parse time).\n",
    "# The modified expression is then evaluated at run-time.\n",
    "# This contrast with normal functions that, at runtime, take the input values (arguments) and return a computed value.\n",
    "\n",
    "# Macro definition..\n",
    "macro unless(test_expr, branch_expr)\n",
    "  quote\n",
    "    if !$test_expr\n",
    "      $branch_expr\n",
    "    end\n",
    "  end\n",
    "end\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array does not contain 3\n"
     ]
    }
   ],
   "source": [
    "# Macro call..\n",
    "array = [1, 2, 'b']\n",
    "@unless 3 in array println(\"array does not contain 3\") # here test_expr is \"3 in array\" and branch_expr is \"println(\"array does not contain 3\")\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array does not contain 3\n"
     ]
    }
   ],
   "source": [
    "# The \"expanded\" macro will look like:\n",
    "array = [1, 2, 'b']\n",
    "\n",
    "if !(3 in array)\n",
    "  println(\"array does not contain 3\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array has fewer than 10 elements\n"
     ]
    }
   ],
   "source": [
    "# We can reuse the macro for different expressions..\n",
    "@unless length(array) >= 10 println(\"array has fewer than 10 elements\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}