\documentclass[a4paper]{article}
\usepackage{listings}
\usepackage{fontspec}
\usepackage[margin=1in]{geometry}

\input{fasto.sty}

\renewcommand{\thesection}{Task \arabic{section}}
\renewcommand{\thesubsection}{\alph{subsection})}

\setmonofont[Scale=0.9]{Antikor Mono Medium}

\setlength{\parskip}{5pt}
\setlength{\parindent}{0pt}

\begin{document}
\section{}
\begin{enumerate}
    \item I am a DIKU Computer Science BSc, general profile
    \item I have little to no proficiency with F\#
    \item I have mininal knowledge of assembly programming
    \item I'm very interested in the topic of compilers
\end{enumerate}

\section{}

\subsection{Completeness and Correctness}
All the requested features have been implemented fully. All 10 possible expressions are accounted for, which can be seen by testing each individually, or together.

The program has shown to give the correct answers in all test cases.

Both completeness and correctness can be shown in these tests, all of which return correct results:

\begin{lstlisting}
    Welcome to the calculator! Type "exit" to stop.
    Input an expression : 1+2+3+4-(5+6)
    Evaluation result   : INT -1
    Input an expression : let x=7 in (x*8+9)
    Evaluation result   : INT 65
    Input an expression : sum x=1 to 10 of (prod y=x to 10 of y)
    Evaluation result   : INT 9864100
    Input an expression : max x = 0 to 10 of 5*x-x*x
    Evaluation result   : INT 6
    Input an expression : argmax x = 0 to 10 of 5*x-x*x
    Evaluation result   : INT 2
\end{lstlisting}

\subsection{Effeciency}
The program runs efficiently and with no obvious uses of excessive memory.

Any singular expression, apart from the \texttt{OVER} expressions runs in constant time, ignoring any expressions it contains. This means that any expression that contains $n$ non-\texttt{OVER} expressions runs in linear time, $O(n)$.

The \texttt{OVER} expressions contain a loop, meaning they run in linear time by themselves.

\subsection{Code Sharing/Elegance}
The code is made readable and with mininal code duplication. The \texttt{OPERATE} and \texttt{OVER} expressions have code run before the specific expression is determined, which reduced duplication.

\subsection*{The full \texttt{eval} code}

\begin{lstlisting}[language=FSharp]
let rec eval (vtab : SymTab) (e : EXP) : VALUE =
  match e with
    | CONSTANT n -> n
    | VARIABLE v ->
      lookup v vtab
    | OPERATE (op, e1, e2) ->
      let (INT exp1) = eval vtab e1
      let (INT exp2) = eval vtab e2
      match op with
        | BPLUS -> INT (exp1 + exp2)
        | BMINUS -> INT (exp1 - exp2)
        | BTIMES -> INT (exp1 * exp2)
    | LET_IN (var, e1, e2) ->
      let exp1 = eval vtab e1
      let vtab = bind var exp1 vtab
      eval vtab e2
    | OVER (rop, var, e1, e2, e3) ->
      let (INT exp1) = eval vtab e1
      let (INT exp2) = eval vtab e2
      let results = [
        for i in exp1..exp2 ->
          let vtab = bind var (INT i) vtab
          eval vtab e3
      ]
      match rop with
        | RSUM -> List.fold (fun (INT acc) (INT elem) -> INT (acc + elem)) (INT 0) results
        | RPROD -> List.fold (fun (INT acc) (INT elem) -> INT (acc * elem)) (INT 1) results
        | RMAX -> List.fold (fun (INT acc) (INT elem) -> INT (max acc elem)) results[0] results
        | RARGMAX ->
          let max_elem = List.fold (fun (INT acc) (INT elem) -> INT (max acc elem)) results[0] results
          INT ((List.findIndex ((=) max_elem) results) + exp1)
\end{lstlisting}

\section{}
\subsection{The \texttt{mul} function}
\begin{lstlisting}[language=Fasto]
fun int mul(int x, int y) =
  if y == 0 then 0
  else if y < 0 then mul(x, y+1) - x
  else mul(x, y-1) + x
\end{lstlisting}

The \texttt{mul} functions is recursive. The base level, when \texttt{y} is 0, 0 is returned. In all other cases, \texttt{y} is moved 1 step closer to 0, and \texttt{x} is either added or subtracked from the final result.

\subsection{The \texttt{dif} array}
\begin{lstlisting}[language=Fasto, firstnumber=16]
let dif = map(fn int (int x) => if x == 0 then arr[x] else arr[x] - arr[x-1], iota(n)) in
\end{lstlisting}

The \texttt{dif} array is constructed using an anonymous function in a \texttt{map} function call.

\subsection*{The full Fasto code}
\begin{lstlisting}[language=Fasto]
fun int mul(int x, int y) =
  if y == 0 then 0
  else if y < 0 then mul(x, y+1) - x
  else mul(x, y-1) + x

fun int readInt(int i) = read(int)

fun int squareSum(int x, int y) = x + mul(y, y)

fun int main() =
  let n = read(int) in
  if n == 0 then let a = write("Incorrect Input!") in 0
  else if n < 0 then let a = write("Incorrect Input!") in 0
  else
    let arr = map(readInt, iota(n)) in
    let dif = map(fn int (int x) => if x == 0 then arr[x] else arr[x] - arr[x-1], iota(n)) in
    write(reduce(squareSum, 0, dif))

\end{lstlisting}

\end{document}