Optimization of F# string manipulation

Question

Hello, I am just learning F# and have been converting a library of C# extension methods to F#. I am currently working on implementing a function called ConvertFirstLetterToUppercase based on the C# implementation below:

public static string ConvertFirstLetterToUppercase(this string value) {
    if (string.IsNullOrEmpty(value)) return value;
    if (value.Length == 1) return value.ToUpper();
    return value.Substring(0, 1).ToUpper() + value.Substring(1);
}

The F# implementation

[<System.Runtime.CompilerServices.ExtensionAttribute>]
module public StringHelper
    open System
    open System.Collections.Generic
    open System.Linq

    let ConvertHelper (x : char[]) =  
        match x with
            | [| |] | null -> ""
            | [| head; |] -> Char.ToUpper(head).ToString()
            | [| head; _ |] -> Char.ToUpper(head).ToString() + string(x.Skip(1).ToArray())

    [<System.Runtime.CompilerServices.ExtensionAttribute>]
    let ConvertFirstLetterToUppercase (_this : string) =
        match _this with
        | "" | null -> _this
        | _ -> ConvertHelper (_this.ToCharArray())

Can someone show me a more concise implementation utilizing more natural F# syntax?

Answer 1

Try the following

[<System.Runtime.CompilerServices.ExtensionAttribute>]
module StringExtensions = 
    let ConvertFirstLetterToUpperCase (data:string) =
        match Seq.tryFind (fun _ -> true) data with
        | None -> data
        | Some(c) -> System.Char.ToUpper(c).ToString() + data.Substring(1)

The tryFind function will return the first element for which the lambda returns true. Since it always returns true it will simply return the first element or None. Once you've established there is at least one element you know data is not null and hence can call Substring

Answer 2

open System

type System.String with
    member this.ConvertFirstLetterToUpperCase() =
        match this with
        | null -> null
        | "" -> ""
        | s -> s.[0..0].ToUpper() + s.[1..]

Usage:

> "juliet".ConvertFirstLetterToUpperCase();;
val it : string = "Juliet"

Answer 3

Something like this?

[<System.Runtime.CompilerServices.ExtensionAttribute>]
module public StringHelper = 
[<System.Runtime.CompilerServices.ExtensionAttribute>]
let ConvertFirstLetterToUppercase (t : string) =
    match t.ToCharArray() with
    | null -> t
    | [||] -> t
    | x -> x.[0] <- Char.ToUpper(x.[0]); System.String(x)

Answer 4

There's nothing wrong with using .NET library functions from a .NET language. Maybe a direct translation of your C# extension method is most appropriate, particularly for such a simple function. Although I'd be tempted to use the slicing syntax like Juliet does, just because it's cool.

open System
open System.Runtime.CompilerServices

[<Extension>]
module public StringHelper =

    [<Extension>]
    let ConvertFirstLetterToUpperCase(this:string) =
        if String.IsNullOrEmpty this then this
        elif this.Length = 1 then this.ToUpper()
        else this.[0..0].ToUpper() + this.[1..]