notebooks/JupyterKernelForLogtalkOverview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "44e0933b",
   "metadata": {
    "tags": []
   },
   "source": [
    "# A Jupyter Kernel for Logtalk\n",
    "\n",
    "This notebook provides an overview of the functionality and implementation of the Logtalk Jupyter kernel.\n",
    "\n",
    "Running this notebook assumes Logtalk is installed using one of the provided installers or by running the manual installation script.\n",
    "\n",
    "The default backend can be changed in the fly by adding a code cell at the top and running one of the following queries: `eclipse`, `gnu`, `sicstus`, `trealla`, `xvm`, or `yap` (assuming that all these backend Prolog systems are installed). The default backend can be set for all notebooks in a directory by using a `logtalk_kernel_config.py` file (see the [logtalk-jupyter-kernel](https://github.com/LogtalkDotOrg/logtalk-jupyter-kernel) repo for details). If this file is not present, the default backend is SWI-Prolog.\n",
    "\n",
    "This notebook is currently running using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "31fe8179",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Logtalk 3.86.0-b01\n",
       "SWI-Prolog 9.3.14\n",
       "Logtalk Jupyter kernel 0.15.0-beta"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%versions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "235f081f",
   "metadata": {},
   "source": [
    "## Execute queries\n",
    "\n",
    "Code cells can contain queries, multiple terms to be interpreted as directives and clauses to be added to a file, or code to be highlighted. By default, the contents of a code cell is interpreted as a query. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "94c585eb",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mVersionData = logtalk(3,86,0,b01)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "current_logtalk_flag(version_data, VersionData)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e2c194d",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mX = [1,2,3],\n",
       "Z = [1,2,3,4,5,6]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = [1,2,3], list::append(X, [4,5,6], Z)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1fae0ab-cf79-4f1d-ba12-0af85854cbdc",
   "metadata": {},
   "source": [
    "We can also write multiple queries in a single cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6774b322-5c98-467e-aa09-5af08f3baefe",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mUnicode = full"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mEncodingDirective = full"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "current_logtalk_flag(unicode, Unicode).\n",
    "current_logtalk_flag(encoding_directive, EncodingDirective)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8afd42d3",
   "metadata": {},
   "source": [
    "## Access and reuse query bindings\n",
    "\n",
    "The variable bindings from previous queries can be accessed by using the `%bindings` line magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "adf87d90",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "$VersionData = logtalk(3,86,0,b01)\n",
       "$X = [1,2,3]\n",
       "$Z = [1,2,3,4,5,6]\n",
       "$Unicode = full\n",
       "$EncodingDirective = full"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%bindings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f8ab82e",
   "metadata": {},
   "source": [
    "Variable bindings can be reused using the corresponding `$Var` term. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6e854d1a",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123456"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mZ = [1,2,3,4,5,6]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "forall(list::member(X, $Z), write(X)).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47417af",
   "metadata": {},
   "source": [
    "We can also print the previous queries using the `%queries` line magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0896d3f9",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "jupyter::versions,\n",
       "current_logtalk_flag(version_data,VersionData),\n",
       "X=[1,2,3],list::append(X,[4,5,6],Z),\n",
       "current_logtalk_flag(unicode,Unicode),\n",
       "current_logtalk_flag(encoding_directive,EncodingDirective),\n",
       "jupyter::print_variable_bindings,\n",
       "forall(list::member(X,Z),write(X))."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%queries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5313ece",
   "metadata": {},
   "source": [
    "## Define predicates\n",
    "\n",
    "Predicates can be defined in `user` by using the `%%user` cell magic in the first line of a code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "566ce3e6",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%user\n",
    "\n",
    "my_append([], Res, Res).\n",
    "my_append([H|T], List, [H|Res]) :-\n",
    "  my_append(T, List, Res)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eabdf604",
   "metadata": {},
   "source": [
    "Running a code cell defining predicates adds them to the database of the running kernel, making them available for use in queries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a181ae15",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mR = [1,2,3,4]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_append([1,2], [3,4], R)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dfcbfd0",
   "metadata": {},
   "source": [
    "Predicate definitions can be split in multiple cells. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "aca6b6dc",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%user\n",
    "\n",
    "fact(a).\n",
    "fact(b)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24cb3ab",
   "metadata": {},
   "source": [
    "In the next cell, the previous clauses are replaced by new ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "be2a0e50",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%user\n",
    "\n",
    "fact(c).\n",
    "fact(d)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6b6b19e4-3ed1-4190-b0b2-e00d739aa8f8",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mL = [c,d]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "findall(X, fact(X), L)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75aef399",
   "metadata": {},
   "source": [
    "But new clauses can be added instead by declaring a predicate *discontiguous* and later using instead the `%%user+` cell magic (think of `+` as meaning append):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "16e1b545",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%user\n",
    "\n",
    ":- discontiguous(a/1).\n",
    "a(1).\n",
    "a(2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "35670af2",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%user+\n",
    "\n",
    "b(3).\n",
    "a(4)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "009dc51b",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a(1).\n",
       "a(2).\n",
       "a(4).\n",
       "\n",
       "b(3).\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "listing(a/1), listing(b/1)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df1363b-16e1-4417-b674-2a667829a41c",
   "metadata": {},
   "source": [
    "## Define objects, protocols, and categories\n",
    "\n",
    "Logtalk entities are preferably defined using the `%%file FILENAME` or `%%file+ FILENAME` cell magic (the `+` variant appends to an existing file instead of redefining it). For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5bd25431-1d38-4f4b-af30-cc4a23cef4e9",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%file foo.lgt\n",
    "\n",
    ":- object(foo).\n",
    "\n",
    "    :- public(bar/0).\n",
    "    bar :-\n",
    "        write('Hello world!\\n').\n",
    "\n",
    ":- end_object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03eb5229",
   "metadata": {},
   "source": [
    "Running a code cell defining Logtalk entities adds them to the database of the running kernel, making them available for use in queries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "50806251-0905-4bfa-aa4e-ad2754e7ddb7",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello world!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "foo::bar."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f00af85d",
   "metadata": {},
   "source": [
    "## Highlight Code\n",
    "\n",
    "Sometimes we want to simply display some code in a cell, benefiting from syntax highlight. This can be accomplished by using the `%%highlight` cell magic. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "778d5c36",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [],
   "source": [
    "%%highlight\n",
    "\n",
    ":- object(hello_world).\n",
    "\n",
    "\t% the initialization/1 directive argument is automatically executed\n",
    "\t% when the object is loaded into memory:\n",
    "\t:- initialization(write('Hello World!\\n')).\n",
    "\n",
    ":- end_object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ee0669",
   "metadata": {},
   "source": [
    "## Handling Multiple Solutions\n",
    "\n",
    "As a notebook code cell doesn't provide the same interactive features of a traditional top-level interpreter, we can either ask for the next solution for a query in the next cell or, if practical/feasible, ask for all solutions at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f4ebf82f",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mM = a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list::member(M, [a,b,c])."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "182656ba",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mM = b"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "jupyter::retry."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "402730b9-5c9c-4061-8ce8-6ab51c106c7a",
   "metadata": {},
   "source": [
    "We can also simply type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3b90f60e-fd3a-49e8-afb1-14bcb7f83e60",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mM = c"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "retry."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09bc734c",
   "metadata": {},
   "source": [
    "In altenative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "821d5f2d",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mL = [a,b,c]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "findall(M, list::member(M, [a,b,c]), L)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc02e4c7",
   "metadata": {},
   "source": [
    "## Debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20aa92ea-26f5-4419-b856-5d3f2dd47588",
   "metadata": {},
   "source": [
    "The Logtalk `debugger` tool is loaded by default when we start a kernel. To illustrate, we load an example, compiling it in debug mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bb65b95d-cc52-4272-8902-2b03e3c1b0c6",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "set_logtalk_flag(debug, on), {elephants(loader)}."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9835148-2db7-4cc3-adc7-11ac3a90c124",
   "metadata": {},
   "source": [
    "Try one of examples queries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "65c863bb-1799-4824-ad71-3f0f53a6536c",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mN = 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fred::number_of_legs(N)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f39233e-712b-486b-a68a-e7c6880ad203",
   "metadata": {},
   "source": [
    "Debugging cannot be performed interactively. But we can print the trace of a goal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "11e55ba0",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "   Call: (1) fred::number_of_legs(_32436)\n",
       "   Call: (2) number_of_legs(_32436)\n",
       "   Fact: (2) number_of_legs(4)\n",
       "   Exit: (2) number_of_legs(4)\n",
       "   Exit: (1) fred::number_of_legs(4)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mN = 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "debugger::trace, fred::number_of_legs(N), debugger::notrace."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e08c34c",
   "metadata": {},
   "source": [
    "We can also use spy points to narrow the debugging output. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0a81cfc1",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     All specified breakpoints added.\n",
       "+  Call: (6) gravitational_acceleration(_18670)\n",
       "+  Fact: (6) gravitational_acceleration(3.72076)\n",
       "+  Exit: (6) gravitational_acceleration(3.72076)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mW2 = 14.88304"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "{planets(loader)}, debugger::spy(gravitational_acceleration/1), mars::weight(m2, W2)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f971d443-c47f-42d2-b729-8bec41606815",
   "metadata": {},
   "source": [
    "Turn off debugging and compiling in debug mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fc9f4f09",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "debugger::nodebug, set_logtalk_flag(debug, off)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9c8e72",
   "metadata": {},
   "source": [
    "## Running Tests\n",
    "\n",
    "Tests can be run by loading their driver file. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "83adb1d7-a886-4a51-aaa0-366a882c545c",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "% \n",
       "% tests started at 2024-11-15, 17:17:05\n",
       "% \n",
       "% running tests from object tests\n",
       "% file: /Users/pmoura/logtalk/examples/ack/tests.lgt\n",
       "% \n",
       "% ack_1: success (in 0.000323000/0.001000000 cpu/wall seconds)\n",
       "% ack_2: success (in 0.006006000/0.007000000 cpu/wall seconds)\n",
       "% ack_3: success (in 0.025594000/0.031000000 cpu/wall seconds)\n",
       "% \n",
       "% 3 tests: 0 skipped, 3 passed, 0 failed (0 flaky)\n",
       "% runtime: 0.031923000/0.039000000 cpu/wall seconds\n",
       "% completed tests from object tests\n",
       "% \n",
       "% \n",
       "% clause coverage ratio and covered clauses per entity predicate\n",
       "% \n",
       "% ack: ack/3 - 3/3 - (all)\n",
       "% ack: 3 out of 3 clauses covered, 100.000000% coverage\n",
       "% \n",
       "% 1 entity declared as covered containing 3 clauses\n",
       "% 1 out of 1 entity covered, 100.000000% entity coverage\n",
       "% 3 out of 3 clauses covered, 100.000000% clause coverage\n",
       "% \n",
       "% tests ended at 2024-11-15, 17:17:05\n",
       "% "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "{ack(tester)}."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3276c9f1",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Benchmarking Capabilities\n",
    "\n",
    "Whenever a query is executed, its runtime is stored in the database and can be accessed immediately after:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a4115b4e",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mM = 1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list::member(M, [1,2,3])."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2af1675d",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Query:   list::member(M,[1,2,3])\n",
       "Runtime: 0.0 s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "jupyter::print_query_time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a7c9e08",
   "metadata": {},
   "source": [
    "## Structured Output\n",
    "\n",
    "Query bindings can be displayed in a table with a row per solution and a column per variable binding by using the `%%table` cell magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d4c3e970",
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Number | Square | \n",
       ":- | :- | \n",
       "10 | 100 | \n",
       "20 | 400 | \n",
       "30 | 900 | \n",
       "40 | 1600 | "
      ],
      "text/plain": [
       "Number | Square | \n",
       ":- | :- | \n",
       "10 | 100 | \n",
       "20 | 400 | \n",
       "30 | 900 | \n",
       "40 | 1600 | "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%table\n",
    "list::member(Number, [10,20,30,40]), Square is Number*Number."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f70dbad",
   "metadata": {},
   "source": [
    "Columns for variables whose name starts with an underscore are omitted. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f76cdf0e",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Position | Element | \n",
       ":- | :- | \n",
       "1 | 10 | \n",
       "2 | 20 | \n",
       "3 | 30 | \n",
       "4 | 40 | "
      ],
      "text/plain": [
       "Position | Element | \n",
       ":- | :- | \n",
       "1 | 10 | \n",
       "2 | 20 | \n",
       "3 | 30 | \n",
       "4 | 40 | "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%table\n",
    "_List = [10,20,30,40], list::nth1(Position, _List, Element)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49dc1e89-b8b4-4698-a615-424e1a166419",
   "metadata": {},
   "source": [
    "## Printing terms\n",
    "\n",
    "Complex compound terms can be displayed as a tree by using the `%%tree` cell magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "21bd5f19-ea65-4daa-9b6a-c4d7dbba9ec4",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.0 (20241103.1931)\n",
       " -->\n",
       "<!-- Pages: 1 -->\n",
       "<svg width=\"216pt\" height=\"310pt\"\n",
       " viewBox=\"0.00 0.00 216.00 309.50\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 305.5)\">\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-305.5 212,-305.5 212,4 -4,4\"/>\n",
       "<!-- 1 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>1</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"27\" cy=\"-195\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"27\" y=\"-189.95\" font-family=\"Times,serif\" font-size=\"14.00\">1</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>2</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"73\" cy=\"-106.5\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"73\" y=\"-101.45\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>3</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"109\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"109\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>4</title>\n",
       "<ellipse fill=\"none\" stroke=\"black\" cx=\"181\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"181\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">4</text>\n",
       "</g>\n",
       "<!-- a(1,b(2,c(3,4))) -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>a(1,b(2,c(3,4)))</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"69,-301.5 15,-301.5 15,-265.5 69,-265.5 69,-301.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"42\" y=\"-278.45\" font-family=\"Times,serif\" font-size=\"14.00\">a</text>\n",
       "</g>\n",
       "<!-- a(1,b(2,c(3,4)))&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>a(1,b(2,c(3,4)))&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M39.04,-265.41C37.02,-253.76 34.29,-238.05 31.95,-224.52\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"35.42,-224.1 30.27,-214.84 28.53,-225.29 35.42,-224.1\"/>\n",
       "<text text-anchor=\"middle\" x=\"39.22\" y=\"-234.2\" font-family=\"Times,serif\" font-size=\"14.00\">1</text>\n",
       "</g>\n",
       "<!-- b(2,c(3,4)) -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>b(2,c(3,4))</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"126,-213 72,-213 72,-177 126,-177 126,-213\"/>\n",
       "<text text-anchor=\"middle\" x=\"99\" y=\"-189.95\" font-family=\"Times,serif\" font-size=\"14.00\">b</text>\n",
       "</g>\n",
       "<!-- a(1,b(2,c(3,4)))&#45;&gt;b(2,c(3,4)) -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>a(1,b(2,c(3,4)))&#45;&gt;b(2,c(3,4))</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M53.26,-265.41C61.25,-253.29 72.13,-236.77 81.28,-222.89\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"84.15,-224.89 86.73,-214.61 78.31,-221.04 84.15,-224.89\"/>\n",
       "<text text-anchor=\"middle\" x=\"78.98\" y=\"-234.2\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
       "</g>\n",
       "<!-- b(2,c(3,4))&#45;&gt;2 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>b(2,c(3,4))&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M93.86,-176.91C90.3,-165.06 85.48,-149.02 81.37,-135.34\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"84.79,-134.57 78.56,-126 78.09,-136.59 84.79,-134.57\"/>\n",
       "<text text-anchor=\"middle\" x=\"91.7\" y=\"-145.7\" font-family=\"Times,serif\" font-size=\"14.00\">1</text>\n",
       "</g>\n",
       "<!-- c(3,4) -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>c(3,4)</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"172,-124.5 118,-124.5 118,-88.5 172,-88.5 172,-124.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"145\" y=\"-101.45\" font-family=\"Times,serif\" font-size=\"14.00\">c</text>\n",
       "</g>\n",
       "<!-- b(2,c(3,4))&#45;&gt;c(3,4) -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>b(2,c(3,4))&#45;&gt;c(3,4)</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M108.09,-176.91C114.47,-164.9 123.15,-148.59 130.48,-134.8\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"133.46,-136.66 135.06,-126.19 127.28,-133.37 133.46,-136.66\"/>\n",
       "<text text-anchor=\"middle\" x=\"129.5\" y=\"-145.7\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
       "</g>\n",
       "<!-- c(3,4)&#45;&gt;3 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>c(3,4)&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M137.89,-88.41C132.88,-76.37 126.06,-59.99 120.31,-46.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"123.63,-45.04 116.56,-37.16 117.17,-47.73 123.63,-45.04\"/>\n",
       "<text text-anchor=\"middle\" x=\"133.6\" y=\"-57.2\" font-family=\"Times,serif\" font-size=\"14.00\">1</text>\n",
       "</g>\n",
       "<!-- c(3,4)&#45;&gt;4 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>c(3,4)&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M152.11,-88.41C157.12,-76.37 163.94,-59.99 169.69,-46.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"172.83,-47.73 173.44,-37.16 166.37,-45.04 172.83,-47.73\"/>\n",
       "<text text-anchor=\"middle\" x=\"169.6\" y=\"-57.2\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "digraph {\n",
       "\"1\" [shape=\"oval\", label=\"1\"]\n",
       "\"2\" [shape=\"oval\", label=\"2\"]\n",
       "\"3\" [shape=\"oval\", label=\"3\"]\n",
       "\"4\" [shape=\"oval\", label=\"4\"]\n",
       "\"a(1,b(2,c(3,4)))\" [shape=\"rect\", label=\"a\"]\n",
       "\"b(2,c(3,4))\" [shape=\"rect\", label=\"b\"]\n",
       "\"c(3,4)\" [shape=\"rect\", label=\"c\"]\n",
       "    \"a(1,b(2,c(3,4)))\" -> \"1\" [label=\"1\", color=\"black\", style=\"solid\"]\n",
       "    \"a(1,b(2,c(3,4)))\" -> \"b(2,c(3,4))\" [label=\"2\", color=\"black\", style=\"solid\"]\n",
       "    \"b(2,c(3,4))\" -> \"2\" [label=\"1\", color=\"black\", style=\"solid\"]\n",
       "    \"b(2,c(3,4))\" -> \"c(3,4)\" [label=\"2\", color=\"black\", style=\"solid\"]\n",
       "    \"c(3,4)\" -> \"3\" [label=\"1\", color=\"black\", style=\"solid\"]\n",
       "    \"c(3,4)\" -> \"4\" [label=\"2\", color=\"black\", style=\"solid\"]\n",
       "}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tree\n",
    "a(1, b(2, c(3, 4)))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfaa314",
   "metadata": {},
   "source": [
    "## Cell and line magic\n",
    "\n",
    "Help on available cell and line magic can be printed using either the `jupyter::magic` query or by using the `%magic` line magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "40a56623",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cell magic:\n",
       "\n",
       "    %%load FILE.EXT\n",
       "        Saves and loads a file using the logtalk_load/2 predicate\n",
       "    %%save FILE.EXT\n",
       "        Saves a file\n",
       "    %%file FILE.EXT\n",
       "        Saves and loads a file using the logtalk_load/2 predicate\n",
       "    %%file+ FILE.EXT\n",
       "        Appends to a file and loads it using the logtalk_load/2 predicate\n",
       "    %%user\n",
       "        Saves and loads a user.lgt file using the logtalk_load/2 predicate\n",
       "    %%user+\n",
       "        Appends to a user.lgt file and loads it using the logtalk_load/2 predicate\n",
       "\n",
       "    %%table\n",
       "        Prints a table with a column per variable binding for all goal solutions\n",
       "    %%tree\n",
       "        Prints a tree representation of a term\n",
       "\n",
       "    %%highlight\n",
       "        Highlights cell contents as Logtalk code\n",
       "\n",
       "Line magic:\n",
       "\n",
       "    %bindings\n",
       "        Prints variable bindings from previous queries\n",
       "    %queries\n",
       "        Prints previous queries\n",
       "\n",
       "    %pwd\n",
       "        Prints the current working directory\n",
       "\n",
       "    %help\n",
       "        Prints documentation for all predicates from object jupyter\n",
       "    %versions\n",
       "        Prints Logtalk, Prolog backend, and Jupyter kernel versions\n",
       "    %flags\n",
       "        Prints a table with all Logtalk flags and their values\n",
       "\n",
       "    %magic\n",
       "        Prints help in using cell and line magic"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%magic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd941d61",
   "metadata": {},
   "source": [
    "## Introspection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26ffa7b6",
   "metadata": {},
   "source": [
    "- Various `jupyter` predicates\n",
    "    - Access documentation with a help predicate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1b7fc919",
   "metadata": {
    "scrolled": true,
    "tags": [],
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "jupyter::halt or halt\n",
       "\n",
       "    Shuts down the running Logtalk process.\n",
       "\n",
       "    The next time code is to be executed, a new process is started.\n",
       "    Everything defined in the database before does not exist anymore.\n",
       "\n",
       "    Corresponds to the functionality of halt/0.\n",
       "    Has the same effect as interrupting or restarting the Jupyter kernel.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::help\n",
       "\n",
       "    Outputs the documentation for all predicates from object jupyter.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::versions\n",
       "\n",
       "    Prints Logtalk, Prolog backend, and Jupyter kernel versions.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::magic\n",
       "\n",
       "    Outputs the documentation for all cell and line magic.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_query_time\n",
       "\n",
       "    Prints the previous query and its runtime in seconds.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_queries(+Ids)\n",
       "\n",
       "    Prints previous queries which were executed in requests with IDs in Ids.\n",
       "\n",
       "    Any $Var terms might be replaced by the variable's name.\n",
       "    This is the case if a previous query with ID in Ids contains Var.\n",
       "    Otherwise, $Var is not replaced.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_table(+Goal)\n",
       "\n",
       "    Computes all results of the goal Goal with findall/3.\n",
       "    These are printed in a table.\n",
       "    Values for variable names starting with an underscore are omitted.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "    Example: jupyter::print_table(current_logtalk_flag(Name, Value)).\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_table(+ValuesLists, +VariableNames)\n",
       "\n",
       "    Prints a table of the values in ValuesLists.\n",
       "\n",
       "    ValuesLists is a list of lists of the same length.\n",
       "    Each list corresponds to one line of the table.\n",
       "\n",
       "    VariableNames is used to fill the header of the table.\n",
       "    If VariableNames=[], capital letters are used.\n",
       "    Otherwise, VariableNames needs to be a list of ground terms.\n",
       "    It needs to be of the same length as the values lists.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "    Can be used with a predicate like findall/3, but not directly.\n",
       "    Instead, a previous binding can be accessed with a $Var term.\n",
       "\n",
       "    Examples:\n",
       "        jupyter::print_table([[10,100],[20,400],[30,900]], ['X', 'Y']).\n",
       "        jupyter::print_table($ResultLists, []).\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_transition_graph(+PredSpec, +FromIndex, +ToIndex, +LabelIndex)\n",
       "\n",
       "    Finds all solutions of the predicate with specification PredSpec.\n",
       "    Prints a graph interpreting the solutions as transitions.\n",
       "\n",
       "    PredSpec needs to be of the form PredName/PredArity.\n",
       "\n",
       "    FromIndex and ToIndex point to predicate arguments used as nodes.\n",
       "    LabelIndex points to the argument providing a label for an edge.\n",
       "    If LabelIndex=0, no label is shown.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::show_term(+Term)\n",
       "\n",
       "    Displays a term as a graph.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::print_variable_bindings\n",
       "\n",
       "    Prints variable bindings from previous queries.\n",
       "    For each variable, the latest value it was bound to is shown.\n",
       "\n",
       "    The variable value can be accessed with a $Var term by any query.\n",
       "    In that case, the term is replaced by the value.\n",
       "    If there is no previous value, an error message is printed.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::pwd\n",
       "\n",
       "    Prints the current working directory.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::cd(+Directory)\n",
       "\n",
       "    Changes the current working directory.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::retry or retry\n",
       "\n",
       "    Causes backtracking of the latest active query.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::set_prolog_backend(+Backend)\n",
       "\n",
       "    Activates the given Prolog backend.\n",
       "\n",
       "    Needs to be the only goal of a query.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
       "\n",
       "jupyter::trace(+Goal)\n",
       "\n",
       "    Prints the trace of the goal Goal.\n",
       "\n",
       "    Logtalk code needs to be compiled in debug mode.\n",
       "    By default, no port is leashed so that no user interaction is requested.\n",
       "    All previously set breakpoints are still active.\n",
       "\n",
       "    Needs to be the only goal of a query in order to work as expected."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "jupyter::help."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fde4e5ea",
   "metadata": {},
   "source": [
    "- Various `juypter` (mostly convenience) predicates\n",
    "- Difficult to remember all of them\n",
    "    - In addition to completion and inspection: predicate to print all documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc61e90-a8ad-41fa-aeec-37aa4f2e05de",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Jupyter\n",
    "\n",
    "- Originates from the **IPython** project\n",
    "    - Enables interactive Python development\n",
    "    - Several frontends, including a former version of **Jupyter Notebook**\n",
    "        - Web application for handling Jupyter notebooks\n",
    "        - Planned to be replaced by **JupyterLab**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ec5ff2",
   "metadata": {},
   "source": [
    "- *Two-process model*:\n",
    "\n",
    "    - Client process: responsible for user interaction\n",
    "    - Kernel process: handles code execution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad708ac3-8d47-4ee8-8171-7c786550c288",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Architecture\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fa42e79-c7d5-4ca6-b831-8fc7ad30adf3",
   "metadata": {
    "tags": []
   },
   "source": [
    "Kernel split in three:\n",
    "- Extends IPython kernel: **inherits** the communication with a frontend via the ZeroMQ protocol\n",
    "\n",
    "\n",
    "- Does not interpret Logtalk itself\n",
    "    - Starts an existing Logtalk instance in a **subprocess**\n",
    "        - Communicates with it according to the JSON-RPC 2.0 protocol\n",
    "    - For any code execution **request**:\n",
    "        - Sends a request message to the Logtalk server containing the **code**\n",
    "        - Terms are read from the code and handled\n",
    "    \n",
    "    \n",
    "- Make the kernel **extensible**: additional layer of a *kernel implementation* in between\n",
    "    - **Responsible** for basically all functionality (e.g. handling Logtalk **server**)\n",
    "    - For every request the kernel receives, a **method** of the implementation class is called\n",
    "    - Kernel started: loads **config** file\n",
    "        - Can contain paths to interpreter-specific Python class files\n",
    "    - By **extending** default implementation class and **overriding** methods\n",
    "        - Kernel behaviour can be adjusted\n",
    "    - Had to be done to support predicate inspection for both    \n",
    "- Configure to start a different Logtalk server"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8323263c",
   "metadata": {},
   "source": [
    "## Changing the Prolog Backend\n",
    "\n",
    "- Switch between Prolog backends on the fly\n",
    "- The previous server process is kept running\n",
    "    - When switching back, the database state has not changed\n",
    "\n",
    "Several Prolog backends are supported and shortcuts are provided to switch to them if installed:\n",
    "\n",
    "- ECLiPSe (`eclipse`)\n",
    "- GNU Prolog (`gnu`)\n",
    "- SICStus Prolog (`sicstus`)\n",
    "- SWI-Prolog (`swi`)\n",
    "- Trealla Prolog (`trealla`)\n",
    "- XVM (`xvm`)\n",
    "- YAP (`yap`)\n",
    "\n",
    "The above shortcuts assume Logtalk was installed using either one of the provided installers or by running the manual installation script (i.e. you can run e.g. Logtalk with SWI-Prolog by simply typing `swilgt` on a POSIX system or `swilgt.ps1` on a Windows system). Alternatively, that you're running Logtalk from a git clone directory with the `LOGTALKHOME` and `LOGTALKUSER` environment variables defined and pointing to the clone directory (i.e. you can run e.g. Logtalk with SWI-Prolog by simply typing `swilgt.sh` on a POSIX system). But you can always switch Prolog backends using the `jupyter::set_prolog_backend(BackendIntegrationScript)` predicate instead (e.g. `jupyter::set_prolog_backend('swilgt.sh')`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "84fa034a",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mtrue"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gnu."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616a5e9e-48ea-4a07-997b-d73f73e8b8d4",
   "metadata": {},
   "source": [
    "Define our own list append predicate and consult it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "15202e77-f240-424c-95e6-9d5609772d73",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1myes"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%file app.pl\n",
    "\n",
    "app([], List, List).\n",
    "app([Head| Tail], List, [Head| Tail2]) :-\n",
    "    app(Tail, List, Tail2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "6bf764e0",
   "metadata": {
    "vscode": {
     "languageId": "logtalk"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1mR = [1,2,3]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "app([1,2], [3], R)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ddac35f",
   "metadata": {},
   "source": [
    "## Extending the Kernel\n",
    "\n",
    "- Original Prolog only kernel was developed for SICStus Prolog and later extended to SWI-Prolog\n",
    "- Current Logtalk kernel supports those and other Prolog backends (including ECLiPSe, GNU Prolog, Trealla Prolog, XVM, and YAP)\n",
    "- Portable code except for the non-standard stream redirection details that depend on the backend\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135ec7c8",
   "metadata": {},
   "source": [
    "- By **replacing the Logtalk server**, the Python part can easily support a different implementation\n",
    "    - Requirements: receive requests as JSON-RPC 2.0 messages, handle them, and send responses\n",
    "    - Might be possible to further extend the existing server with conditional compilation\n",
    "        - Advanced features might require significant changes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac2a6913",
   "metadata": {},
   "source": [
    "- By **overriding the `LogtalkKernelBaseImplementation` class**, most of the basic kernel behaviour can be adjusted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2b7918e",
   "metadata": {},
   "source": [
    "- Server replacement:\n",
    "    - Extend existing:\n",
    "        - Implementing **basic code execution** should not require major effort\n",
    "        - More **advanced features** might involve significant changes\n",
    "\n",
    "- Replacement of the server does not suffice?: Python extension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b2c2011",
   "metadata": {},
   "source": [
    "## Future Work\n",
    "\n",
    "- Support other Prolog backends (waiting on requests to their maintainers for missing functionality)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a9bfce9",
   "metadata": {},
   "source": [
    "- Combine strengths of several Prolog backends\n",
    "    - Kernel can be connected with multiple servers at once\n",
    "    - Reusing results for another one should be relatively easy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2550d887",
   "metadata": {},
   "source": [
    "- Send commands to all available Logtalk servers *at once*\n",
    "    - Detect differences in the behaviour\n",
    "    - Compare the performance by using the benchmarking functionality"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Logtalk",
   "language": "logtalk",
   "name": "logtalk_kernel"
  },
  "language_info": {
   "codemirror_mode": "logtalk",
   "file_extension": ".lgt",
   "mimetype": "text/x-logtalk",
   "name": "Logtalk"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}