How convert first char to lowerCase-CodePudding

Try to play with string and I have string like: "Hello.Word" or "stackOver.Flow"

and i what first char convert to lower case: "hello.word" and "stackOver.flow"

For snakeCase it easy we need only change UpperCase to lower and add '_' but in camelCase (with firs char in lower case) i dont know how to do this

open System

let convertToSnakeCase (value:string) =
   String [| 
     Char.ToLower value.[0]
     for ch in value.[1..] do
       if Char.IsUpper ch then '_'
       Char.ToLower ch |]

Who can help?

module Identifier =

    open System

    let changeCase (str : string) =
        if String.IsNullOrEmpty(str) then str
        else
            let isUpper = Char.IsUpper
            let n = str.Length
            let builder = new System.Text.StringBuilder()
            let append (s:string) = builder.Append(s) |> ignore
            let rec loop i j =
                let k = 
                    if i = n  (isUpper str.[i] && (not (isUpper str.[i - 1]) 
                                 ((i   1) <> n && not (isUpper str.[i   1])))) 
                        then
                        if j = 0 then
                            append (str.Substring(j, i - j).ToLower())
                        elif (i - j) > 2 then
                            append (str.Substring(j, 1))
                            append (str.Substring(j   1, i - j - 1).ToLower())
                        else
                            append (str.Substring(j, i - j))
                        i
                    else
                        j
                if i = n then builder.ToString()
                else loop (i   1) k
            loop 1 0

    type System.String with
        member x.ToCamelCase() = changeCase x

    printfn "%s" ("StackOver.Flow".ToCamelCase()) //stackOver.Flow
//need stackOver.flow

CodePudding user response：

I suspect there are much more elegant and concise solutions, I sense you are learning functional programming, so I think its best to do stuff like this with recursive function rather than use some magic library function. I notice in your question you ARE using a recusive function, but also an index into an array, lists and recursive function work much more easily than arrays, so if you use recursion the solution is usually simpler if its a list.

I'd also avoid using a string builder, assuming you are learning fp, string builders are imperative, and whilst they obviously work, they wont help you get your head around using immutable data.

The key then is to use the pattern match to match the scenario that you want to use to trigger the upper/lower case logic, as it depends on 2 consecutive characters.

I THINK you want this to happen for the 1st char, and after a '.'?

(I've inserted a '.' as the 1st char to allow the recursive function to just process the '.' scenario, rather than making a special case).

let convertToCamelCase (value : string) = 
    let rec convertListToCamelCase (value : char list) = 
        match value with
        | [] -> []
        | '.' :: second :: rest ->
            '.' :: convertListToCamelCase (Char.ToLower second :: rest)
        | c :: rest -> 
            c :: convertListToCamelCase rest
    // put a '.' on the front to simplify the logic (and take it off after)
    let convertAsList = convertListToCamelCase ('.' :: (value.ToCharArray() |> Array.toList))
    String ((convertAsList |> List.toArray).[1..])

The piece to worry about is the recusive piece, the rest of it is just flipping an array to a list and back again.