Learning haskell recently has really highlighted the power of the built in classes of haskell.

Compare a function in haskell to captialize the first letter in a sentence, vs c#.

Haskell

1
2
3
4
5

import Data.Char
 
sentenceCase :: [Char] -> [Char]
sentenceCase [] = []
sentenceCase (x:xs) = [toUpper x] ++ map toLower xs

I think to be fair I should explain what the above function does.

1. The first line is the type definition, states that the function will accept a list of chars (a string) and return a list of chars.
2. The second line is a pattern match, in that if an empty string is provided then it will return an empty string.
3. The third line is also a pattern match, however will only be accepted if the first pattern is passed over
4. So in this case it will be run when accepting a non-empty string as it’s input parameter.

So in 1 line of code you could read the above function as taking a list of characters, return the first element as uppercase and the remainder as lowercase.

Vs C#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public static string ToSentenceCase(this string original)
{
	return String.IsNullOrEmpty(original) 
		? original 
		: string.Format("{0}{1}", Head(original).ToUpper(), Tail(original).ToLower());
}
 
public static string Head(this string original)
{
	return String.IsNullOrEmpty(original) 
		? original 
		: original.First().ToString();
}
 
public static string Tail(this string original)
{
	return String.IsNullOrEmpty(original) 
		? original 
		: original.Substring(1, original.Length - 1);
}

To be fair, c# doesn’t have a Head or Tail method built in. However even using extension classes, the built in pattern matching from Haskell seems to be a far nicer solution language wise than c#.

Is there a way to refactor this c# code futher?