anchor.diff:      member __.TypeParameters: TypeParameterDeclaration option = typeParameters
       override _.Print(printer) =
           printer.PrintFunction(Some id, ``params``, body, loc)
  +        printer.PrintNewLine()
   
   // Expressions
   
  
positive.code:             body.Print(printer)
  
          // TODO: type annotations
          member printer.PrintFunction(id: Identifier option, ``params``: Pattern array, body: BlockStatement, loc) =
              printer.Print("function ", ?loc=loc)
              printer.PrintOptional(id)
              printer.Print("(")
              printer.PrintCommaSeparatedArray(``params``)
              printer.Print(") ")
              body.Print(printer)
  
          member printer.MaybeWithParens(expr: Expression) =
              match expr with
  
negative.code:                     if i < subSegments.Length then
                          printer.PrintNewLine()
  
          if args.Length = 0 then
              printSegment printer value 0 value.Length
          else
              // Macro transformations
              // https://fable.io/docs/communicate/js-from-fable.html#Emit-when-F-is-not-enough
              let value =
                  value
                  |> replace @"\$(\d+)\.\.\." (fun m ->
                      let rep = ResizeArray()
                      let i = int m.Groups.[1].Value
                      for j = i to args.Length - 1 do
                          rep.Add("$" + string j)
                      String.concat ", " rep)
  
                  |> replace @"\{\{\s*\$(\d+)\s*\?(.*?)\:(.*?)\}\}" (fun m ->
                      let i = int m.Groups.[1].Value
                      match args.[i] with
                      | :? BooleanLiteral as b when b.Value -> m.Groups.[2].Value
                      | _ -> m.Groups.[3].Value)
  
                  |> replace @"\{\{([^\}]*\$(\d+).*?)\}\}" (fun m ->
                      let i = int m.Groups.[2].Value
                      match Array.tryItem i args with
                      | Some _ -> m.Groups.[1].Value
                      | None -> "")
  
                  // This is to emit string literals as JS, I think it's no really
                  // used and it shouldn't be necessary with the new emitJsExpr
      //            |> replace @"\$(\d+)!" (fun m ->
      //                let i = int m.Groups.[1].Value
      //                match Array.tryItem i args with
      //                | Some(:? StringLiteral as s) -> s.Value
      //                | _ -> "")
  
              let matches = System.Text.RegularExpressions.Regex.Matches(value, @"\$\d+")
              if matches.Count > 0 then
                      for i = 0 to matches.Count - 1 do
                          let m = matches.[i]
  
                          let segmentStart =
                              if i > 0 then matches.[i-1].Index + matches.[i-1].Length
                              else 0
  
                          printSegment printer value segmentStart m.Index
  
                          let argIndex = int m.Value.[1..]
                          match Array.tryItem argIndex args with
                          | Some e -> printer.MaybeWithParens(e)
                          | None -> printer.Print("(void \"missing\")")
  
                      let lastMatch = matches.[matches.Count - 1]
                      printSegment printer value (lastMatch.Index + lastMatch.Length) value.Length
  
              else
                  printer.Print(value)
  
  // Template Literals
  //type TemplateElement(value: string, tail, ?loc) =
  