anchor.diff:      (* variant for numeric literals like "1.0". *)
       | Number of double
       (* variant for a binary operator. *)
  -    | BinaryOperation of Op: Operator * Lhs: Expr * Rhs: Expr
  +    | BinaryOperation of (Operator * Expr * Expr)
       (* variant for referencing a variable, like "a". *)
       | Variable of Name: string
       (* variant for function calls. *)
  -    | Call of FunctionName: string * Arguments: seq<Expr>
  +    | Call of (string * seq<Expr>)
   
       override expr.ToString() =
         match expr with
  -      | BinaryOperation (Op=op; Lhs=lhs; Rhs=rhs) -> sprintf "%A %A %A" lhs op rhs
  -      | Number n -> sprintf "%A : Number" n
  -      | Variable identifier -> sprintf "%s : Variable" identifier 
  -      | Call(FunctionName=fn;Arguments=args) ->
  +      | BinaryOperation (op, lhs, rhs) -> sprintf "%s %s %s" (lhs.ToString()) (string op) (rhs.ToString())
  +      | Number n -> sprintf "%f" n
  +      | Variable identifier -> sprintf "%s" identifier 
  +      | Call(fn, args) ->
           let argRepresentation =
             args
             |> Seq.map string
             |> String.concat ", "
  -        sprintf "Call %s (%s)" fn argRepresentation
  +        sprintf "%s (%s)" fn argRepresentation
     
     type Operator =
       | Plus
  
positive.code: 
      override op.ToString() = op.Code
  
  
    (* proto - This type represents the "prototype" for a function, which captures
     * its name, and its argument names (thus implicitly the number of arguments the
     * function takes). *)
    type Prototype = Prototype of String
  
    (* func - This type represents a function definition itself. *)
    type Function = Function of Prototype: Prototype * Body: Expr
  
  module Lexer =
    open FParsec
    open Token
    
    let parseLeftParen = pstring LeftParen
  
    let parseRightParen = pstring RightParen
  
    let parseComma = pstring Comma
    let isSymbolicOperatorChar = isAnyOf SpecialCharacters
    let remainingOperatorCharsAndWhiteSpace = manySatisfy isSymbolicOperatorChar .>> spaces
  
    let parseWhiteSpace = spaces
  
    let parseBetweenBrackets = between parseLeftParen parseRightParen
  
  module Parser =
    open FParsec
    open AST
    open Lexer
  
    type private AST.Operator with
    
      member op.Precedence =
        match op with
        | Plus -> 20
        | LessThan -> 10
        | Minus -> 30
        | Multiply -> 40
  
      member op.Associativity =
        match op with
        | Plus -> Associativity.Left
        | _ -> Associativity.Left
  
    type UserState = unit
  
    let parseExpr, parseExprRef = createParserForwardedToRef<Expr, _>()
  
    let parseValue =
  
      let parseNumber : Parser<Expr, UserState> = pfloat .>> spaces |>> Number
  
      let parseVariable : Parser<Expr, UserState> = 
        let options = IdentifierOptions()
        let parseIdentifierWithOptions = identifier options
        parseIdentifierWithOptions .>> spaces |>> Variable
  
      let parseCall =
        let parseArgs =
          let parseExprs = sepBy parseExpr parseComma
          between parseLeftParen parseRightParen parseExprs
        let operator = parseVariable
        operator .>>. parseArgs |>> (fun (fn, args) -> 
          let (Variable name) = fn
          Call(name, args)
        )
  
      choice [
        parseNumber
        attempt parseCall
        attempt parseVariable
      ]
    
    let addSymbolicInfixOperators (op : Operator) opp =
      let operator = 
        InfixOperator(
          op.Code,
          remainingOperatorCharsAndWhiteSpace,
          op.Precedence,
          op.Associativity,
          (),
          fun _ lhs rhs ->
            BinaryOperation(op, lhs, rhs)
      )
      (opp : OperatorPrecedenceParser<_, _, _>).AddOperator(operator)
    
    let operatorPrecendenceParser = 
      let parseTerm = 
        parseValue .>> parseWhiteSpace
        <|> parseBetweenBrackets parseExpr
      let opp = OperatorPrecedenceParser()
      do 
        opp.TermParser <- parseTerm
        addSymbolicInfixOperators LessThan opp
        addSymbolicInfixOperators Plus opp
        addSymbolicInfixOperators Minus opp
        addSymbolicInfixOperators Multiply opp
      opp
  
    let parseBinaryOperation = operatorPrecendenceParser.ExpressionParser
  
    do parseExprRef := parseBinaryOperation
         
    let showResult = 
      function
      | Success(result, _, _) ->
  
negative.code:         printfn ""
          printfn "☠️ %s" message
          printfn ""
  
  module Driver =
  
  