examples/BuildingAnInterpreterFromScratch/CK-Flavored-S-Expression-Interpreter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CK Flavored S-Expression Interpreter\n",
    "\n",
    "Scrope to [Playground](#playground) at the bottom to see it in action\n",
    "\n",
    "**Note**: S-Expressions were chosen because they're really easy to tokenize/parse, and I could skip to grokking interpreters. If you're looking to build your own language, have the parser do more than what is demonstrated below, something akin to what I did in [MinimalMermaidParser.ipynb](../BuildingAParserFromScratch/MinimalMermaidParser.ipynb) would make your life significantly easier, is easier to understand/maintain, etc.\n",
    "\n",
    "✅ Variables\n",
    "\n",
    "✅ Simple Functions\n",
    "\n",
    "✅ Function Closures\n",
    "\n",
    "✅ 1st Class/Higher Order Functions\n",
    "\n",
    "✅ Globals (print, concat)\n",
    "\n",
    "✅ Classes\n",
    "\n",
    "✅ Class Inheritance\n",
    "\n",
    "✅ Numbers (Decimal)\n",
    "\n",
    "✅ Strings\n",
    "\n",
    "✅ Math Operators (+, -, *, /, %)\n",
    "\n",
    "⚠️ .NET Interop (Need To Add Generics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prelude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "using System.Text.RegularExpressions;\n",
    "using static Microsoft.DotNet.Interactive.Formatting.PocketViewTags;\n",
    "using Microsoft.DotNet.Interactive.Formatting;\n",
    "using Microsoft.DotNet.Interactive;\n",
    "using System.Reflection;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>Newtonsoft.Json, 13.0.1</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget:Newtonsoft.Json\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "using Newtonsoft.Json;\n",
    "\n",
    "public class ToStringJsonConverter : JsonConverter\n",
    "{\n",
    "    public override bool CanConvert(Type objectType) => true;\n",
    "    public override bool CanRead => false;\n",
    "\n",
    "    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)\n",
    "    {\n",
    "        writer.WriteValue(value?.ToString());\n",
    "    }\n",
    "\n",
    "    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)\n",
    "    {\n",
    "        return existingValue == null\n",
    "               ? null\n",
    "               : Activator.CreateInstance(objectType, new[] { existingValue });\n",
    "    }\n",
    "}\n",
    "\n",
    "public static string ToJson(this object obj)\n",
    "{\n",
    "    try\n",
    "    {\n",
    "        return JsonConvert.SerializeObject(obj, Formatting.Indented);\n",
    "    }\n",
    "    catch (JsonSerializationException)\n",
    "    {\n",
    "        return JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.Objects });\n",
    "    }\n",
    "}\n",
    "\n",
    "public static DisplayedValue DisplayAsJson(this object obj)\n",
    "{\n",
    "    return obj.ToJson().DisplayAs(\"application/json\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenize S-Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "static IEnumerable<string> Tokenize(string sExpression)\n",
    "{\n",
    "    var regex = new Regex(@\"[\\(|\\)]|\"\"[^\"\"]*\"\"|[^\\s\\(\\)]+\");\n",
    "    \n",
    "    return regex.Matches(sExpression)\n",
    "                .Cast<Match>()\n",
    "                .Select(x => x.Value);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><thead><tr><th><i>index</i></th><th>value</th></tr></thead><tbody><tr><td>0</td><td>(</td></tr><tr><td>1</td><td>begin</td></tr><tr><td>2</td><td>(</td></tr><tr><td>3</td><td>(</td></tr><tr><td>4</td><td>fun</td></tr><tr><td>5</td><td>add</td></tr><tr><td>6</td><td>(</td></tr><tr><td>7</td><td>x</td></tr><tr><td>8</td><td>y</td></tr><tr><td>9</td><td>)</td></tr><tr><td>10</td><td>(</td></tr><tr><td>11</td><td>+</td></tr><tr><td>12</td><td>x</td></tr><tr><td>13</td><td>y</td></tr><tr><td>14</td><td>)</td></tr><tr><td>15</td><td>)</td></tr><tr><td>16</td><td>)</td></tr><tr><td>17</td><td>)</td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Tokenize(@\"(begin (\n",
    "    (fun add (x y)\n",
    "        (+ x y)\n",
    "    )\n",
    "))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parse S-Expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "// Wrapper for strings so we can differentiate them in our ASTs (Abstract Syntax Trees)\n",
    "[JsonConverter(typeof(ToStringJsonConverter))]\n",
    "readonly struct Str\n",
    "{\n",
    "    private readonly string _str;\n",
    "    public Str(string str) => _str = str ?? throw new ArgumentNullException(nameof(str));\n",
    "    public override string ToString() => _str;\n",
    "}\n",
    "\n",
    "// NOTE: This assumes a well formed S-Expression\n",
    "//       (ex: it does NOT check for balanced parens, etc.)\n",
    "\n",
    "///<summary>Convert a sequence of tokens to an S-Expression object[] AST</summary>\n",
    "static object?[] Parse(IEnumerable<string> tokens)\n",
    "{\n",
    "    var stack = new Stack<List<object?>>();\n",
    "\n",
    "    foreach (var token in tokens)\n",
    "    {\n",
    "        if (token == \"(\")\n",
    "        {\n",
    "            stack.Push(new List<object?>());\n",
    "        }\n",
    "        else if (token == \")\")\n",
    "        {\n",
    "            var arr = stack.Pop().ToArray();\n",
    "            \n",
    "            if (stack.Count == 0)\n",
    "                return arr;\n",
    "            \n",
    "            stack.Peek().Add(arr);\n",
    "        }\n",
    "        else\n",
    "        {\n",
    "            var value = token == \"null\"\n",
    "                        ? null\n",
    "                        : decimal.TryParse(token, out var number)\n",
    "                        ? (object)number\n",
    "                        : token.Length > 1 && token.StartsWith('\"') && token.EndsWith('\"')\n",
    "                        ? new Str(token[1..^1])\n",
    "                        : token;\n",
    "\n",
    "            stack.Peek().Add(value);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "\n",
    "    return stack.Peek().ToArray();\n",
    "}\n",
    "\n",
    "static object ParseFromString(string str)\n",
    "{\n",
    "    var tokens = Tokenize(str);\n",
    "    var ast = Parse(tokens);\n",
    "    return ast;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "application/json": 42
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": ""
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.code.notebook.error": {
       "message": "o.endsWith is not a function",
       "name": "TypeError",
       "stack": "TypeError: o.endsWith is not a function\n\tat c (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:142764)\n\tat i (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:143414)\n\tat l (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:144222)\n\tat h (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:144972)\n\tat Array.map (<anonymous>)\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:146140\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:146457\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:146464\n\tat Array.map (<anonymous>)\n\tat e.jupyterNotebookModelToNotebookData (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:145716)\n\tat e.NotebookSerializer.deserializeNotebook (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\extensions\\ipynb\\dist\\ipynbMain.js:1:156342)\n\tat f.$dataToNotebook (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:94:98450)\n\tat l._doInvokeHandler (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:102:13680)\n\tat l._invokeHandler (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:102:13362)\n\tat l._receiveRequest (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:102:12081)\n\tat l._receiveOneMessage (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:102:11033)\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:102:8941\n\tat h.invoke (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:145)\n\tat v.deliver (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:2266)\n\tat g.fire (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:1844)\n\tat r.fire (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:16515)\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:118:17104\n\tat h.invoke (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:145)\n\tat v.deliver (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:2266)\n\tat g.fire (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:1844)\n\tat r.fire (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:16515)\n\tat o._receiveMessage (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:21327)\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:18770\n\tat h.invoke (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:145)\n\tat v.deliver (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:2266)\n\tat g.fire (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:61:1844)\n\tat g.acceptChunk (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:13346)\n\tat c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:12476\n\tat Socket.i (c:\\Users\\colli\\AppData\\Local\\Programs\\Microsoft VS Code\\resources\\app\\out\\vs\\workbench\\api\\node\\extensionHostProcess.js:70:24594)\n\tat Socket.emit (node:events:526:28)\n\tat addChunk (node:internal/streams/readable:315:12)\n\tat readableAddChunk (node:internal/streams/readable:289:9)\n\tat Readable.push (node:internal/streams/readable:228:10)\n\tat Pipe.onStreamRead (node:internal/stream_base_commons:190:23)"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ParseFromString(\"(42)\").DisplayAsJson();\n",
    "\n",
    "ParseFromString(\"(\\\"Life, The Universe, And Everything.\\\")\").DisplayAsJson();\n",
    "\n",
    "ParseFromString(@\"(begin\n",
    "    (fun makeAdder (x)\n",
    "        (fun capturedAdd (y)\n",
    "            (+ x y)\n",
    "        )\n",
    "    )\n",
    "\n",
    "    (var myAdder (inv makeAdder (42)))\n",
    "\n",
    "    (inv myAdder (99)\n",
    ")\").DisplayAsJson();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope\n",
    "\n",
    "Represents a scope of names and their values (ex: numbers, strings, functions, and classes)\n",
    "\n",
    "Scopes can be nested (ex: a function has its own scope when invoked, and class instances have their own scopes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "class Scope\n",
    "{\n",
    "    // Using [JsonProperty] so these fields will show up when ToJson() and DisplayAsJson() are called\n",
    "    [JsonProperty] public readonly Dictionary<string, object?> _data;\n",
    "    [JsonProperty] private readonly Scope? _parent;\n",
    "\n",
    "    public Scope(Dictionary<string, object?>? data = null,\n",
    "                 Scope? parent = null)\n",
    "    {\n",
    "        _data = data ?? new Dictionary<string, object?>();\n",
    "        _parent = parent;\n",
    "    }\n",
    "\n",
    "    public void Define(string name, object? value)\n",
    "    {\n",
    "        if (_data.ContainsKey(name))\n",
    "            throw new Exception($\"Local scope already contains a name \\\"{name}\\\"\");\n",
    "\n",
    "        _data.Add(name, value);\n",
    "    }\n",
    "\n",
    "    private Dictionary<string, object?>? FindDictionary(string name, bool throwIfNotFound)\n",
    "    {\n",
    "        // Recurse from this scope through\n",
    "        // ancestor scopes looking for a \n",
    "        // Dictionary containing a key name\n",
    "\n",
    "        var handle = this;\n",
    "        do\n",
    "        {\n",
    "            if (handle._data.ContainsKey(name))\n",
    "                return handle._data;\n",
    "        }\n",
    "        while ((handle = handle._parent) != null);\n",
    "\n",
    "        if (throwIfNotFound)\n",
    "            throw new Exception($\"No name \\\"{name}\\\" found in scope\");\n",
    "\n",
    "        return null;\n",
    "    }\n",
    "\n",
    "    public void Set(string name, object? value)\n",
    "    {\n",
    "        var data = FindDictionary(name, true)!;\n",
    "        data[name] = value;\n",
    "    }\n",
    "\n",
    "    public object? Get(string name)\n",
    "    {\n",
    "        return FindDictionary(name, true)![name];\n",
    "    }\n",
    "\n",
    "    public bool Exists(string name)\n",
    "    {\n",
    "        return FindDictionary(name, false) is not null;\n",
    "    }\n",
    "\n",
    "    public Scope CreateChildScope()\n",
    "    {\n",
    "        return new Scope(parent: this);\n",
    "    }\n",
    "\n",
    "    public Scope? ParentScope()\n",
    "    {\n",
    "        return _parent;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "source": [
    "## Interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "// Facilitates failing fast which is\n",
    "// important since this interpreter\n",
    "// largely traverses object arrays\n",
    "\n",
    "public static void Expect(object[] ast, string? expectedTag = null, int? minLength = null, int? exactLength = null)\n",
    "{\n",
    "    if (ast == null)\n",
    "        throw new ArgumentNullException(nameof(ast));\n",
    "\n",
    "\n",
    "    if (expectedTag is not null)\n",
    "    {\n",
    "        if (string.IsNullOrWhiteSpace(expectedTag))\n",
    "            throw new ArgumentOutOfRangeException(nameof(expectedTag), $\"If provided, {nameof(expectedTag)} should not be empty or whitespace\");\n",
    "        \n",
    "        if (expectedTag.Trim() != expectedTag)\n",
    "            throw new Exception($\"{nameof(expectedTag)} should not have leading or trailing whitespace\");\n",
    "        \n",
    "        if ((ast[0] as string) != expectedTag)\n",
    "            throw new Exception($\"Was expecting tag \\\"{expectedTag}\\\" but found \\\"{ast[0]}\\\"\");\n",
    "    }\n",
    "\n",
    "\n",
    "    if (minLength is not null && minLength < 1)\n",
    "        throw new ArgumentOutOfRangeException(nameof(minLength), $\"{minLength} must be null or greater than or equal to one.\");\n",
    "\n",
    "    if (exactLength is not null && exactLength < 1)\n",
    "        throw new ArgumentOutOfRangeException(nameof(exactLength), $\"{exactLength} must be null or greater than or equal to one.\");\n",
    "\n",
    "    if (minLength is not null && exactLength is not null)\n",
    "        throw new ArgumentOutOfRangeException(nameof(exactLength), $\"At most either {nameof(exactLength)} or {nameof(minLength)} should be defined\");\n",
    "\n",
    "    if (minLength is not null && minLength > ast.Length)\n",
    "        throw new Exception($\"Was expecting {nameof(ast)} to be at least of length {minLength} but was of length {ast.Length}\");\n",
    "\n",
    "    if (exactLength is not null && exactLength != ast.Length)\n",
    "        throw new Exception($\"Was expecting {nameof(ast)} to be of length {exactLength} but was of length {ast.Length}\");\n",
    "}\n",
    "\n",
    "public static T Expect<T>(this object obj)\n",
    "{\n",
    "    if (obj is not T)\n",
    "        throw new Exception($\"Was expecting type {typeof(T).Name} but was of type {obj?.GetType().Name ?? \"null\"}\");\n",
    "    \n",
    "    return (T)obj;\n",
    "}\n",
    "\n",
    "public static T ExpectNotNull<T>(this T? obj)\n",
    "{\n",
    "    return obj ?? throw new Exception($\"Was expecting non-null {typeof(T).Name} but was null\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "#nullable enable\n",
    "\n",
    "class Interpreter\n",
    "{\n",
    "    class Function\n",
    "    {\n",
    "        public string Name { get; init; }\n",
    "        public Scope Closure { get; init; }\n",
    "        public string[] Parameters { get; init; }\n",
    "        public object Body { get; init; }\n",
    "    }\n",
    "\n",
    "    class Member\n",
    "    {\n",
    "        public string Name { get; init; }\n",
    "        public string[] Parameters { get; init; }\n",
    "        public object[] Body { get; init; }\n",
    "    }\n",
    "\n",
    "    class Class\n",
    "    {\n",
    "        public string Name { get; init; }\n",
    "        public string[] FieldNames { get; init; }\n",
    "        public Member Constructor { get; init; }\n",
    "        public Dictionary<string, Member> Methods { get; init; }\n",
    "        public Scope Closure { get; init; }\n",
    "        public Class? Ancestor { get; init; }\n",
    "    }\n",
    "\n",
    "    class ClassInstance\n",
    "    {\n",
    "        public Class Class { get; init; }\n",
    "        public Scope Scope { get; init; }\n",
    "        public ClassInstance? Parent { get; init; }\n",
    "    }\n",
    "\n",
    "    class DotNetClassInstance\n",
    "    {\n",
    "        public object Instance { get; init;}\n",
    "    }\n",
    "\n",
    "    readonly Scope globalScope;\n",
    "\n",
    "    static Dictionary<string, Type> dotNetTypes;\n",
    "\n",
    "    public Interpreter(Scope? globalScope = null)\n",
    "    {\n",
    "        this.globalScope = globalScope ?? new Scope();\n",
    "\n",
    "        // Using an instance to populate a static to be friendly with .NET Interactive\n",
    "        dotNetTypes = this\n",
    "                      .GetType()\n",
    "                      .Assembly\n",
    "                      .GetReferencedAssemblies()\n",
    "                      .Select(an => System\n",
    "                                    .Reflection\n",
    "                                    .Assembly\n",
    "                                    .Load(an.FullName))\n",
    "                      .SelectMany(a => a.GetExportedTypes())\n",
    "                      .DistinctBy(t => t.FullName)\n",
    "                      .ToDictionary(t => t.FullName!, t => t);\n",
    "    }\n",
    "\n",
    "    static object? Print(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"print\", minLength: 2);\n",
    "\n",
    "        object? value = null;\n",
    "        foreach (var x in ast.Skip(1))\n",
    "        {\n",
    "            value = Interpreter.Expression(ast[1], scope);\n",
    "\n",
    "            if (value == null || value is string || value.GetType().IsPrimitive)\n",
    "                value.Display();\n",
    "            else\n",
    "                value.ToJson().Display();\n",
    "        }\n",
    "\n",
    "        return value;\n",
    "    }\n",
    "\n",
    "    static object? VariableDeclaration(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"var\", exactLength: 3);\n",
    "\n",
    "        var name = ast[1].Expect<string>();\n",
    "        \n",
    "        var value = ast.Length == 3\n",
    "                    ? Expression(ast[2], scope)\n",
    "                    : null;\n",
    "        \n",
    "        scope.Define(name, value);\n",
    "\n",
    "        return value;\n",
    "    }\n",
    "\n",
    "    static object? SetVariable(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"set\", exactLength: 3);\n",
    "\n",
    "        var name = ast[1].Expect<string>();\n",
    "        var value = Expression(ast[2], scope);\n",
    "\n",
    "        scope.Set(name, value);\n",
    "\n",
    "        return value;\n",
    "    }\n",
    "\n",
    "    static bool Math(string tag, object[] ast, Scope scope, out decimal? result)\n",
    "    {\n",
    "        if (!new[] { \"+\", \"-\", \"*\", \"/\", \"%\" }.Contains(tag))\n",
    "        {\n",
    "            result = null;\n",
    "            return false;\n",
    "        }\n",
    "\n",
    "        if (ast.Length != 3)\n",
    "            throw new Exception($\"{nameof(ast)} for infix math operators is expected to be of length 3 but was of length {ast.Length}\");\n",
    "\n",
    "        var a = Expression(ast[1], scope);\n",
    "        var b = Expression(ast[2], scope);\n",
    "\n",
    "        if (!(a is decimal) || !(b is decimal))\n",
    "            throw new Exception($\"Both arguments must be decimals; however, a is {a?.GetType().Name ?? \"null\"} and b is {b?.GetType().Name ?? \"null\"}\");\n",
    "\n",
    "        var aDec = a.Expect<decimal>();\n",
    "        var bDec = b.Expect<decimal>();\n",
    "\n",
    "        result = tag switch\n",
    "        {\n",
    "            \"+\" => aDec + bDec,\n",
    "            \"-\" => aDec - bDec,\n",
    "            \"*\" => aDec * bDec,\n",
    "            \"/\" => aDec / bDec,\n",
    "            \"%\" => aDec % bDec,\n",
    "            _ => throw new NotImplementedException()\n",
    "        };\n",
    "\n",
    "        return true;\n",
    "    }\n",
    "\n",
    "    static object? Block(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"begin\", minLength: 1);\n",
    "        \n",
    "        scope = scope.CreateChildScope();\n",
    "\n",
    "        object? res = null;\n",
    "        for (int i = 1; i < ast.Length; i++)\n",
    "            res = Expression(ast[i], scope);\n",
    "\n",
    "        return res;\n",
    "    }\n",
    "\n",
    "    static object? DefineFunction(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"fun\", minLength: 4);\n",
    "\n",
    "        var name = ast[1].Expect<string>();\n",
    "        var parameters = ast[2].Expect<object[]>().Cast<string>().ToArray();\n",
    "        var body = ast[3];\n",
    "\n",
    "        if (parameters.Distinct().Count() != parameters.Length)\n",
    "            throw new Exception(\"Parameters of Functions must have distinct names within a single Function.\"); // TODO: Better message\n",
    "\n",
    "        var function = new Function\n",
    "        {\n",
    "            Name = name,\n",
    "            Closure = scope,\n",
    "            Parameters = parameters,\n",
    "            Body = body\n",
    "        };\n",
    "\n",
    "        scope.Define(name, function);\n",
    "\n",
    "        return function;\n",
    "    }\n",
    "\n",
    "    static object? InvokeFunction(Function func, object[] args)\n",
    "    {\n",
    "        var funcScope = func.Closure.CreateChildScope();\n",
    "\n",
    "        if (func.Parameters.Length != args.Length)\n",
    "            throw new Exception($\"{func.Name} expects {func.Parameters.Length} argument(s) but was supplied {args.Length}\");\n",
    "        for (int i = 0; i < func.Parameters.Length; i++)\n",
    "            funcScope.Define(func.Parameters[i], args[i]);\n",
    "\n",
    "        return Expression(func.Body, funcScope);\n",
    "    }\n",
    "\n",
    "    static object? InvokeFunctionOrMethod(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"inv\", exactLength: 3);\n",
    "\n",
    "        var name = ast[1].Expect<string>();\n",
    "        var args = ExpressionArray(ast[2].Expect<object[]>(), scope);\n",
    "\n",
    "        if (!name.Contains('.'))\n",
    "        {\n",
    "            var funcObj = scope.Get(name);\n",
    "            if (!(funcObj is Function))\n",
    "                throw new Exception($\"Function named \\\"{name}\\\" was expected to be in scope; however, \\\"{name}\\\" is of type {funcObj?.GetType().Name ?? \"null\"}\");\n",
    "            var func = (Function)funcObj;\n",
    "\n",
    "            return InvokeFunction(func, args.Expect<object[]>());\n",
    "        }\n",
    "        else\n",
    "        {\n",
    "            var nameParts = name.Split('.');\n",
    "            var instanceName = nameParts[0];\n",
    "            var methodName = nameParts[1];\n",
    "\n",
    "            var instance = scope.Get(instanceName);\n",
    "\n",
    "            switch (instance)\n",
    "            {\n",
    "                case ClassInstance classInstance:\n",
    "                    var method = classInstance.Class.Methods[methodName];\n",
    "                    return ApplyMember(method, args.Expect<object[]>(), classInstance.Scope);\n",
    "\n",
    "                case DotNetClassInstance dotNetInstance:\n",
    "                    var argTypes = args.Select(x => x.GetType()).ToArray();\n",
    "                    var methodInfo = dotNetInstance.Instance.GetType().GetMethod(methodName, argTypes).ExpectNotNull();\n",
    "                    return methodInfo.Invoke(dotNetInstance.Instance, args);\n",
    "\n",
    "                default:\n",
    "                    throw new NotImplementedException();\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    static Class DefineClass(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"class\", minLength: 5); // 5 for plain classes. 7 for classes that inherit.\n",
    "\n",
    "        var className = ast[1].Expect<string>();\n",
    "\n",
    "        var astOffset = 0;\n",
    "        Class? parent = null;\n",
    "        if (ast[2] is \"extends\")\n",
    "        {\n",
    "            astOffset = 2;\n",
    "            parent = scope.Get(ast[3].Expect<string>()).ExpectNotNull().Expect<Class>();\n",
    "        }\n",
    "\n",
    "        var fieldsAst = ast[2 + astOffset].Expect<object[]>();\n",
    "        Expect(fieldsAst, \"fields\", minLength: 1);\n",
    "        var fieldNames = fieldsAst.Skip(1).Cast<string>().ToArray();\n",
    "\n",
    "        var ctorAst = ast[3 + astOffset].Expect<object[]>();\n",
    "        Expect(ctorAst, \"constructor\", minLength: 1);\n",
    "        var ctor = new Member\n",
    "        {\n",
    "            Name = \"constructor\",\n",
    "            Parameters = ctorAst[1].Expect<object[]>().Cast<string>().ToArray(),\n",
    "            Body = ctorAst.Skip(2).Cast<object[]>().ToArray()\n",
    "        };\n",
    "\n",
    "        var methodsAst = ast[4 + astOffset].Expect<object[]>();\n",
    "        Expect(methodsAst, \"methods\", minLength: 1);\n",
    "        var methods = methodsAst\n",
    "                      .Skip(1)\n",
    "                      .Cast<object[]>()\n",
    "                      .Select(methodAst =>\n",
    "                      {\n",
    "                        Expect(methodAst, \"mem\", minLength: 4);\n",
    "                        return new Member\n",
    "                        {\n",
    "                            Name = methodAst[1].Expect<string>(),\n",
    "                            Parameters = methodAst[2].Expect<object[]>().Cast<string>().ToArray(),\n",
    "                            Body = methodAst.Skip(3).ToArray()\n",
    "                        };\n",
    "                      })\n",
    "                      .ToDictionary(m => m.Name,\n",
    "                                    m => m);\n",
    "\n",
    "        var @class = new Class\n",
    "        {\n",
    "            Name = className,\n",
    "            FieldNames = fieldNames,\n",
    "            Constructor = ctor,\n",
    "            Methods = methods,\n",
    "            Closure = scope,\n",
    "            Ancestor = parent\n",
    "        };\n",
    "\n",
    "        scope.Define(@class.Name, @class);\n",
    "\n",
    "        return @class;\n",
    "    }\n",
    "\n",
    "    static void PopulateParameters(Member member, object?[] args, Scope memberScope)\n",
    "    {\n",
    "        if (member.Parameters.Length != args.Length)\n",
    "            throw new Exception($\"{member.Name} expects {member.Parameters.Length} argument(s) but was supplied {args.Length}\");\n",
    "        \n",
    "        for (int i = 0; i < member.Parameters.Length; i++)\n",
    "            memberScope.Define(member.Parameters[i], args[i]);\n",
    "    }\n",
    "\n",
    "    static object? ExecuteMemberBody(object[] memberBody, Scope memberScope)\n",
    "    {\n",
    "        object? res = null;\n",
    "        foreach (var exp in memberBody)\n",
    "            res = Expression(exp, memberScope);\n",
    "        \n",
    "        return res;\n",
    "    }\n",
    "\n",
    "    static object? ApplyMember(Member member, object[] args, Scope classScope)\n",
    "    {\n",
    "        var memberScope = classScope.CreateChildScope();\n",
    "\n",
    "        PopulateParameters(member, args, memberScope);\n",
    "        \n",
    "        return ExecuteMemberBody(member.Body, memberScope);\n",
    "    }\n",
    "\n",
    "    static ClassInstance InstantiateClass(Class @class, object?[] ctorArguments, Scope scope)\n",
    "    {\n",
    "        ClassInstance? ancestor = null;\n",
    "        Scope classScope;\n",
    "        if (@class.Ancestor != null)\n",
    "        {\n",
    "            Expect(@class.Constructor.Body, minLength: 1);\n",
    "            var superAst = @class.Constructor.Body[0].Expect<object[]>();\n",
    "            Expect(superAst, \"super\", exactLength: 2);\n",
    "\n",
    "            var shimScope = @class.Closure.CreateChildScope();\n",
    "            PopulateParameters(@class.Constructor, ctorArguments, shimScope);\n",
    "\n",
    "            var parentArgs = ExpressionArray(superAst[1].Expect<object[]>(), shimScope);\n",
    "\n",
    "            ancestor = InstantiateClass(@class.Ancestor, parentArgs, @class.Ancestor.Closure);\n",
    "            classScope = ancestor.Scope.CreateChildScope();\n",
    "        }\n",
    "        else\n",
    "        {\n",
    "            classScope = @class.Closure.CreateChildScope();\n",
    "        }\n",
    "\n",
    "        classScope.Define(\"base\", ancestor);\n",
    "        classScope.Define(\"this\", null);\n",
    "        foreach (var name in @class.FieldNames)\n",
    "            classScope.Define(name, null);\n",
    "        \n",
    "        var ctorScope = classScope.CreateChildScope();\n",
    "        PopulateParameters(@class.Constructor, ctorArguments, ctorScope);\n",
    "        var ctorBody = ancestor != null\n",
    "                       ? @class.Constructor.Body.Skip(1).ToArray()\n",
    "                       : @class.Constructor.Body;\n",
    "        ExecuteMemberBody(ctorBody, ctorScope);\n",
    "\n",
    "        var instance = new ClassInstance\n",
    "        {\n",
    "            Class = @class,\n",
    "            Scope = classScope\n",
    "        };\n",
    "        classScope.Set(\"this\", instance);\n",
    "        return instance;\n",
    "    }\n",
    "\n",
    "    static object InstantiateClass(object[] ast, Scope scope)\n",
    "    {\n",
    "        Expect(ast, \"new\", exactLength: 3);\n",
    "\n",
    "        var className = ast[1].Expect<string>();\n",
    "\n",
    "        if (scope.Exists(className))\n",
    "        {\n",
    "            var @class = scope.Get(className)!.Expect<Class>();\n",
    "\n",
    "            var ctorArguments = ExpressionArray(ast[2].Expect<object[]>(), scope);\n",
    "\n",
    "            return InstantiateClass(@class, ctorArguments, scope);\n",
    "        }\n",
    "        else if (dotNetTypes.ContainsKey(className))\n",
    "        {\n",
    "            var type = dotNetTypes[className];\n",
    "\n",
    "            var ctorArguments = ExpressionArray(ast[2].Expect<object[]>(), scope);\n",
    "            \n",
    "            var instance = Activator.CreateInstance(type, ctorArguments);\n",
    "\n",
    "            return new DotNetClassInstance { Instance = instance };\n",
    "        }\n",
    "        else\n",
    "        {\n",
    "            dotNetTypes.Count.Display();\n",
    "\n",
    "            throw new Exception($\"No class or .NET type found with name \\\"{className}\\\"\");\n",
    "        }\n",
    "    }\n",
    "\n",
    "    static object? Expression(object? obj, Scope scope)\n",
    "    {\n",
    "        if (obj is decimal\n",
    "            || obj is bool\n",
    "            || obj is null)\n",
    "            return obj;\n",
    "\n",
    "        if (obj is Str)\n",
    "            return obj.ToString();\n",
    "\n",
    "        if (obj is string str)\n",
    "            return scope.Get(str);\n",
    "\n",
    "        if (obj is object[] arr)\n",
    "        {\n",
    "            if (arr.Length == 0)\n",
    "                return null;\n",
    "\n",
    "            if (arr[0] is string tag)\n",
    "            {\n",
    "                if (Math(tag, arr, scope, out var res))\n",
    "                    return res;\n",
    "\n",
    "                if (tag is \"print\")\n",
    "                    return Print(arr, scope);\n",
    "\n",
    "                if (tag is \"begin\")\n",
    "                    return Block(arr, scope);\n",
    "\n",
    "                if (tag is \"var\")\n",
    "                    return VariableDeclaration(arr, scope);\n",
    "\n",
    "                if (tag is \"set\")\n",
    "                    return SetVariable(arr, scope);\n",
    "\n",
    "                if (tag is \"get\")\n",
    "                    return scope.Get((string)arr[1]);\n",
    "\n",
    "                if (tag is \"fun\")\n",
    "                    return DefineFunction(arr, scope);\n",
    "\n",
    "                if (tag is \"inv\")\n",
    "                    return InvokeFunctionOrMethod(arr, scope);\n",
    "\n",
    "                if (tag is \"class\")\n",
    "                    return DefineClass(arr, scope);\n",
    "\n",
    "                if (tag is \"new\")\n",
    "                    return InstantiateClass(arr, scope);\n",
    "\n",
    "                if (tag is \"concat\")\n",
    "                    return string.Concat(arr.Skip(1).Select(x => Expression(x, scope)));\n",
    "            }\n",
    "\n",
    "            if (arr[0] is object[] innerArr && innerArr.Length == 1)\n",
    "                return Expression(innerArr, scope);\n",
    "\n",
    "            if (arr.Length > 1)\n",
    "                throw new NotImplementedException(arr.ToJson());\n",
    "\n",
    "            return Expression(arr[0], scope);\n",
    "        }\n",
    "\n",
    "        throw new NotImplementedException();\n",
    "    }\n",
    "\n",
    "    static object?[] ExpressionArray(object?[] argumentExpressions, Scope scope)\n",
    "    {\n",
    "        return argumentExpressions\n",
    "               .Select(a => Expression(a, scope))\n",
    "               .ToArray();\n",
    "    }\n",
    "\n",
    "    public object? Expression(object obj)\n",
    "    {\n",
    "        return Interpreter.Expression(obj, globalScope);\n",
    "    }\n",
    "\n",
    "    public static object? Interpret(object ast)\n",
    "    {\n",
    "        var interpreter = new Interpreter();\n",
    "        return interpreter.Expression(ast);\n",
    "    }\n",
    "\n",
    "    public static object? Interpret(string str)\n",
    "    {\n",
    "        var tokens = Tokenize(str);\n",
    "        var ast = Parse(tokens);\n",
    "        return Interpret(ast);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playground"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">42</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Life, The Universe, And Everything."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Blocks -------------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "First"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Simple Functions ---------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">141</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Higher Order Functions ---------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\">141</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Classes ------------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Ashley is 36"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Some Literal"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Inheritance --------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "// From ToString on Animal"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Collin"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "// From AnimalToString on Person, which calls base.ToString"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Ashley"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "// From ToString on Person, which shadows Animal.ToString"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Ashley is 36"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       ".NET Interop -------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Hello, World!\r\n",
       "From StringBuilder!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var sExpressions = new[]\n",
    "{\n",
    "    // Numbers\n",
    "    \"(42)\",\n",
    "\n",
    "    // Strings\n",
    "    \"(\\\"Life, The Universe, And Everything.\\\")\",\n",
    "\n",
    "    // Blocks\n",
    "    @\"(begin\n",
    "        (print \"\"Blocks -------------------------------\"\")\n",
    "\n",
    "        (var a \"\"First\"\")\n",
    "\n",
    "        (begin\n",
    "            (var a \"\"Second\"\")\n",
    "            \n",
    "            (begin\n",
    "                (var a \"\"Third\"\")    \n",
    "            )\n",
    "        )\n",
    "\n",
    "        a\n",
    "    )\",\n",
    "\n",
    "    // Simple Functions\n",
    "    @\"(begin\n",
    "        (print \"\"Simple Functions ---------------------\"\")\n",
    "\n",
    "        (fun aFunction (x y)\n",
    "            (+ x y)\n",
    "        )\n",
    "\n",
    "        (inv aFunction (42 99))\n",
    "    )\",\n",
    "\n",
    "    // Higher Order Functions\n",
    "    @\"(begin\n",
    "        (print \"\"Higher Order Functions ---------------\"\")\n",
    "\n",
    "        (fun makeAdder (x)\n",
    "            (fun capturedAdd (y)\n",
    "                (+ x y)\n",
    "            )\n",
    "        )\n",
    "\n",
    "        (var myAdder (inv makeAdder (42)))\n",
    "\n",
    "        (inv myAdder (99))\n",
    "    )\",\n",
    "\n",
    "    // Classes\n",
    "    @\"(begin\n",
    "        (print \"\"Classes ------------------------------\"\")\n",
    "\n",
    "\n",
    "        (class Person\n",
    "            (fields _name _age)\n",
    "            (constructor (name age)\n",
    "                (set _name name)\n",
    "                (set _age age)\n",
    "            )\n",
    "            (methods\n",
    "                (mem GetOlder ()\n",
    "                    (set _age (+ _age 1))\n",
    "                )\n",
    "                (mem ToString ()\n",
    "                    (concat _name \"\" is \"\" _age)\n",
    "                )\n",
    "                (mem SomeLiteral ()\n",
    "                    \"\"Some Literal\"\"\n",
    "                )\n",
    "            )\n",
    "        )\n",
    "\n",
    "        (var p (new Person (\"\"Ashley\"\" 35)))\n",
    "        (inv p.GetOlder ())\n",
    "        (print (inv p.ToString ()))\n",
    "        (inv p.SomeLiteral ())\n",
    "    )\",\n",
    "\n",
    "    // Inheritance\n",
    "    @\"(begin\n",
    "        (print \"\"Inheritance --------------------------\"\")\n",
    "\n",
    "        (class Animal\n",
    "            (fields _name)\n",
    "            (constructor (name)\n",
    "                (set _name name)\n",
    "            )\n",
    "            (methods\n",
    "                (mem ToString ()\n",
    "                    _name\n",
    "                )\n",
    "            )\n",
    "        )\n",
    "\n",
    "        (var a (new Animal (\"\"Collin\"\")))\n",
    "        (print \"\"// From ToString on Animal\"\")\n",
    "        (print (inv a.ToString ()))\n",
    "\n",
    "        (class Person extends Animal\n",
    "            (fields _age)\n",
    "            (constructor (name age)\n",
    "                (super (name))\n",
    "                (set _age age)\n",
    "            )\n",
    "            (methods\n",
    "                (mem GetOlder ()\n",
    "                    (set _age (+ _age 1))\n",
    "                )\n",
    "                (mem AnimalToString ()\n",
    "                    (print \"\"// From AnimalToString on Person, which calls base.ToString\"\")\n",
    "                    (inv base.ToString ())\n",
    "                )\n",
    "                (mem ToString ()\n",
    "                    (print \"\"// From ToString on Person, which shadows Animal.ToString\"\")\n",
    "                    (concat _name \"\" is \"\" _age)\n",
    "                )\n",
    "            )\n",
    "        )\n",
    "\n",
    "        (var p (new Person (\"\"Ashley\"\" 35)))\n",
    "\n",
    "        (inv p.GetOlder ())\n",
    "\n",
    "        (print (inv p.AnimalToString ()))\n",
    "        \n",
    "        (inv p.ToString ())\n",
    "    )\",\n",
    "\n",
    "    // .NET Interop\n",
    "    @\"(begin\n",
    "        (print \"\".NET Interop -------------------------\"\")\n",
    "    \n",
    "        (var sb (new System.Text.StringBuilder ()))\n",
    "        (inv sb.AppendLine (\"\"Hello, World!\"\"))\n",
    "        (inv sb.Append (\"\"From StringBuilder!\"\"))\n",
    "    \n",
    "        (inv sb.ToString ())\n",
    "    )\"\n",
    "};\n",
    "\n",
    "foreach (var sExpression in sExpressions)\n",
    "    Interpreter.Interpret(sExpression).Display();"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}