julia-type-hierarchy/julia-type-hierarchy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Julia: explore type hierarchy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shortly, we will use these two functions to explore Julia's type-system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "function printsub(T::Union{UnionAll,DataType}; first_iter = true, last=false, padding=\"\")\n",
    "    if first_iter\n",
    "        println(T)\n",
    "        # don't print \"| \"\n",
    "        last=true\n",
    "        new_padding = \"\"\n",
    "    else\n",
    "        if last \n",
    "            println(padding * \"┗ \",T)\n",
    "            new_padding = padding * \"  \"\n",
    "        else\n",
    "            println(padding * \"┣ \",T)\n",
    "            new_padding = padding *  \"┃ \"\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    st = subtypes(T)\n",
    "        \n",
    "    if ! isempty(st)\n",
    "        for sub in st[1:lastindex(st)-1] \n",
    "            printsub(sub, first_iter=false, padding=new_padding)\n",
    "        end\n",
    "        printsub(st[end], first_iter=false, last=true, padding=new_padding)\n",
    "    end\n",
    "end\n",
    "\n",
    "function printsuper(T::Union{UnionAll,DataType}, res=T)\n",
    "    if supertype(T) != Any\n",
    "        printsuper(supertype(T), \"$(supertype(T)) -> $res\")\n",
    "    else\n",
    "        println(\"Any -> $res\")\n",
    "    end\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "To summarize some of the most important things about Julia's type system (for more refer to [Julia docs](https://docs.julialang.org/en/v1/manual/types/index.html)):\n",
    "- it is dynamic, but you can indicate that certain values are of specific types\n",
    "- hierarchical relationships are explicitly declared\n",
    "    - all concrete types may only have abstract types as their supertypes\n",
    "    - abstract and concrete types can be parameterized by other types\n",
    "    - abstract types cannot be instantiated\n",
    "- all values in Julia are true objects having a type\n",
    "- the only type a value has is its actual type when the program is running\n",
    "- only values, not variables, have types\n",
    "- a primitive type is a concrete type whose data consists of plain old bits\n",
    "- a composite type is a collection of named fields\n",
    "- functions are not bundled with the objects they operate on\n",
    "    - the types of all of a function's arguments are considered when selecting a method, rather than just the first one\n",
    "    \n",
    "Furthermore, types in Julia are objects, this implies that we may use functions on them. \n",
    "We will be using these build-in functions:\n",
    "- `isa(x, type)`, to test if x is of the given type\n",
    "- `typeof(x)`, to get the type of x\n",
    "- `supertype(T::UnionAll)`, to get the supertype of the UnionAll T\n",
    "- `supertype(T::DataType)`, to get the supertype of the DataType T\n",
    "- `subtypes(T::UnionAll)`, to get a list of imediate subtypes of UnionAll T\n",
    "- `subtypes(T::DataType)`, to get a list of imediate subtypes of DataType T\n",
    "- `isconcretetype(T)`, to determine wheter type T is a concrete type\n",
    "\n",
    "The interesting question is what types have the types that are now viewed as objects. Based on the documentation, experimentation and my assumptions we have several types of types.\n",
    "- `DataType`\n",
    "    - a type of all abstract, primitive, composite types\n",
    "- `Union`\n",
    "    - a type of all types constructed using the Union keyword\n",
    "- `UnionAll`\n",
    "    - a type of parametric types\n",
    "- `Core.TypeofBottom`\n",
    "    - the type of Union{}\n",
    "\n",
    "Maybe you are asking what the types of `DataType`, `Union`, `UnionAll` and `Core.TypeofBottom` are. They are all of the type `DataType`, as we can quickly check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{DataType,1}:\n",
       " DataType\n",
       " DataType\n",
       " DataType\n",
       " DataType"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof.([DataType, Union, UnionAll, Core.TypeofBottom])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, there is a special parametric abstract type called `Type`, which stands for `Type{N} where N`. It has all type objects as its instances and as a parametric type, its type is UnionAll. By the way, the its subtype hierarchy looks like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type{N} where N\n",
      "┣ Core.TypeofBottom\n",
      "┣ DataType\n",
      "┣ Union\n",
      "┗ UnionAll\n"
     ]
    }
   ],
   "source": [
    "printsub(Type{N} where N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And these types of types that are listed above are all contrete types i.e. they can be instantiated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element BitArray{1}:\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isconcretetype.([DataType, Union, UnionAll, Core.TypeofBottom])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a very special thing about `Type{N} where N` after all. \n",
    "\n",
    "Given a type `T`, we can construct `Type{T}` which behaves as an abstract type with exactly one instance (object of this kind), the type `T` itself. Put differently, for some specific `T` is `Type{T}` an object of the type `DataType`. The only value a object of the type `Type{T}` can contain is the type `T`.\n",
    "\n",
    "`Type{T}` is defined by the following property: `isa(A,Type{B})` is true if and only if A and B are the same object and that object is a type. (As it is written in the documentation.)\n",
    "\n",
    "These types are called singleton types and you can read more about them [here](https://docs.julialang.org/en/v1/manual/types/#man-singleton-types-1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All types are implicitly subtypes of `Any`. And `Any` is of the type `DataType`. Of course `Type{N} where N`, shortly called just `Type` is also a subtype of `Any` and so is also `DataType`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "446"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(subtypes(Any))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20-element Array{Any,1}:\n",
       " AbstractArray\n",
       " AbstractChannel\n",
       " AbstractChar\n",
       " AbstractDict\n",
       " AbstractDisplay\n",
       " AbstractSet\n",
       " AbstractString\n",
       " Any\n",
       " Base.AbstractCartesianIndex\n",
       " Base.AbstractCmd\n",
       " Base.AbstractLock\n",
       " Base.ArithmeticStyle\n",
       " Base.AsyncCollector\n",
       " Base.AsyncCollectorState\n",
       " Base.AsyncCondition\n",
       " Base.AsyncGenerator\n",
       " Base.AsyncGeneratorState\n",
       " Base.BaseDocs.Keyword\n",
       " Base.BottomRF\n",
       " Base.Broadcast.BitMaskedBitArray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtypes(Any)[1:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, let's look at some more examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# syntax for UnionAll types allows to omit parameters\n",
    "Array == Array{T, N} where {T,N}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UnionAll"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UnionAll"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Array{Int64})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Array{Int64,2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any -> AbstractArray{T,N} where N where T -> DenseArray{T,N} where N where T -> Array\n"
     ]
    }
   ],
   "source": [
    "printsuper(Array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any -> AbstractArray{Int64,2} -> DenseArray{Int64,2} -> Array{Int64,2}\n"
     ]
    }
   ],
   "source": [
    "# Int is an alias for Int64 (depends on arch.)\n",
    "printsuper(Array{Int,2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DenseArray{T,N} where N where T\n",
      "┣ Array\n",
      "┣ Base.CodeUnits\n",
      "┣ Base.Experimental.Const\n",
      "┣ Random.UnsafeView\n",
      "┣ SharedArrays.SharedArray\n",
      "┗ SuiteSparse.CHOLMOD.Dense\n"
     ]
    }
   ],
   "source": [
    "printsub(DenseArray{T,N} where {T,N})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any -> AbstractArray{Int64,4} -> DenseArray{Int64,4} -> Array{Int64,4}\n"
     ]
    }
   ],
   "source": [
    "# Only declared types (DataType) have unambiguous supertypes.\n",
    "printsuper(Array{Int64,4})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How are numbers structured in Julia?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number\n",
      "┣ Complex\n",
      "┗ Real\n",
      "  ┣ AbstractFloat\n",
      "  ┃ ┣ BigFloat\n",
      "  ┃ ┣ Float16\n",
      "  ┃ ┣ Float32\n",
      "  ┃ ┗ Float64\n",
      "  ┣ AbstractIrrational\n",
      "  ┃ ┗ Irrational\n",
      "  ┣ Integer\n",
      "  ┃ ┣ Bool\n",
      "  ┃ ┣ Signed\n",
      "  ┃ ┃ ┣ BigInt\n",
      "  ┃ ┃ ┣ Int128\n",
      "  ┃ ┃ ┣ Int16\n",
      "  ┃ ┃ ┣ Int32\n",
      "  ┃ ┃ ┣ Int64\n",
      "  ┃ ┃ ┗ Int8\n",
      "  ┃ ┗ Unsigned\n",
      "  ┃   ┣ UInt128\n",
      "  ┃   ┣ UInt16\n",
      "  ┃   ┣ UInt32\n",
      "  ┃   ┣ UInt64\n",
      "  ┃   ┗ UInt8\n",
      "  ┗ Rational\n"
     ]
    }
   ],
   "source": [
    "printsub(Number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AbstractString\n",
      "┣ String\n",
      "┣ SubString\n",
      "┣ SubstitutionString\n",
      "┗ Test.GenericString\n"
     ]
    }
   ],
   "source": [
    "printsub(AbstractString)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(AbstractArray{String,1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AbstractArray{String,1}\n",
      "┣ AbstractRange{String}\n",
      "┃ ┣ LinRange{String}\n",
      "┃ ┣ OrdinalRange{String,S} where S\n",
      "┃ ┃ ┣ AbstractUnitRange{String}\n",
      "┃ ┃ ┗ StepRange{String,S} where S\n",
      "┃ ┗ StepRangeLen{String,R,S} where S where R\n",
      "┣ Base.LogicalIndex{String,A} where A<:(AbstractArray{Bool,N} where N)\n",
      "┣ Base.ReinterpretArray{String,1,S,A} where A<:AbstractArray{S,1} where S\n",
      "┣ Base.ReshapedArray{String,1,P,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where P<:AbstractArray\n",
      "┣ Core.Compiler.AbstractRange{String}\n",
      "┃ ┣ Core.Compiler.LinRange{String}\n",
      "┃ ┣ Core.Compiler.OrdinalRange{String,S} where S\n",
      "┃ ┃ ┣ Core.Compiler.AbstractUnitRange{String}\n",
      "┃ ┃ ┗ Core.Compiler.StepRange{String,S} where S\n",
      "┃ ┗ Core.Compiler.StepRangeLen{String,R,S} where S where R\n",
      "┣ DenseArray{String,1}\n",
      "┃ ┣ Array{String,1}\n",
      "┃ ┣ Base.CodeUnits{String,S} where S<:AbstractString\n",
      "┃ ┣ Base.Experimental.Const{String,1}\n",
      "┃ ┣ Random.UnsafeView{String}\n",
      "┃ ┗ SharedArrays.SharedArray{String,1}\n",
      "┣ JSON.Parser.PushVector{String,A} where A<:AbstractArray{String,1}\n",
      "┣ PermutedDimsArray{String,1,perm,iperm,AA} where AA<:AbstractArray where iperm where perm\n",
      "┣ SparseArrays.AbstractSparseArray{String,Ti,1} where Ti\n",
      "┃ ┗ SparseArrays.SparseVector{String,Ti} where Ti<:Integer\n",
      "┣ SubArray{String,1,P,I,L} where L where I where P\n",
      "┗ Test.GenericArray{String,1}\n"
     ]
    }
   ],
   "source": [
    "printsub(AbstractArray{String,1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in Julia are first-class objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any -> Function\n"
     ]
    }
   ],
   "source": [
    "printsuper(Function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isa(+, Function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thanks for reading."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.0",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}