anchor.diff:      member __.ReturnType: TypeAnnotation option = returnType
       member __.TypeParameters: TypeParameterDeclaration option = typeParameters
       override _.Print(printer) =
  -        // TODO: type annotations
  -        // TODO: Remove parens if we only have one argument (and no annotation)
  -        printer.Print("(", ?loc=loc)
  -        printer.PrintCommaSeparatedArray(``params``)
  -        printer.Print(") => ")
  -        match body with
  -        | U2.Case1 block ->
  -            match block.Body with
  -            | [|:? ReturnStatement as r |] -> r.Argument.Print(printer)
  -            | _ -> printer.PrintBlock(block.Body, skipNewLineAtEnd=true)
  -        | U2.Case2 expr -> expr.Print(printer)
  +        let body =
  +            match body with
  +            | U2.Case1 block -> block
  +            | U2.Case2 expr -> BlockStatement [|ReturnStatement expr|]
  +        printer.PrintFunction(None, ``params``, body, loc, isArrow=true)
   
   type FunctionExpression(``params``, body, ?id, ?returnType, ?typeParameters, ?loc) = //?generator_, ?async_
       inherit Expression("FunctionExpression", ?loc = loc)
  
positive.code:         let inline replace pattern (f: System.Text.RegularExpressions.Match -> string) input =
              System.Text.RegularExpressions.Regex.Replace(input, pattern, f)
  
          // 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 printSegment (printer: Printer) (value: string) segmentStart segmentEnd =
              let segmentLength = segmentEnd - segmentStart
              if segmentLength > 0 then
  
negative.code:     member __.TypeParameters: TypeParameterDeclaration option = typeParameters
      override _.Print(printer) =
          printer.PrintFunction(Some id, ``params``, body, loc)
          printer.PrintNewLine()
  
  // Expressions
  
  