Learning Haskell: string transformations

Question

Knowing little about string manipulation libraries I wanted to write these simple transformations in Haskell myself. I was suprised how much boilerplate I was able to produce. How can I simplify it? Would using regex produce most readable code?

Desired output:

*Main> prettyCamel "foo-bar-example"
"fooBarExample"
*Main> prettyCapitals "foo-bar-example"
"FooBarExample"

Code:

import Data.Char

prettyCapitals = foldr1 (++) . (map capitalize) . splitString
prettyCamel = foldr1 (++) . camelCase . splitString

capitalize (x:xs) = toUpper x : xs

camelCase [] = []
camelCase (x:xs) = x : (map capitalize xs)

splitString :: String -> [String]
splitString = foldr (splittingAdd (== '-')) []

splittingAdd splitPredicate char words = 
 if splitPredicate char
  then "":words
  else (char : headOrEmpty words) : tailOrEmpty words

headOrEmpty [] = ""
headOrEmpty (x:xs) = x

tailOrEmpty [] = []
tailOrEmpty (x:xs) = xs

Regex is not at all idiomatic code for haskell.

Sibi
– Sibi

2014-01-21 17:52:23 +00:00
Commented Jan 21, 2014 at 17:52 — Sibi
– Sibi, Commented Jan 21, 2014 at 17:52

Fred Foo · Accepted Answer · 2014-01-22 11:15:43Z

6

How about using plain old recursion?

prettyCamel ""         =  ""
prettyCamel ('-':c:s)  =  toUpper c : prettyCamel s
prettyCamel (c:s)      =  c : prettyCamel s

prettyCapitals (c:s)   =  toUpper c : prettyCamel s

Alternatively, you can get a point-free version of one of the functions with the Data.List.Split package.

prettyCapitals  =  concatMap capitalize . splitOn "-"
prettyCamel s   =  x : prettyCapitals xs
  where (x:xs)  =  splitOn "-" s

(Using your previous definition of capitalize.)

edited Jan 22, 2014 at 11:15

answered Jan 21, 2014 at 18:10

Fred Foo

365k80 gold badges765 silver badges852 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

karakfa Over a year ago

Pattern matching is a very powerful tool.

Chris Taylor · Accepted Answer · 2014-01-21 18:19:37Z

2

Use libraries and composition!

import Data.Char       (toUpper)
import Data.List.Split (splitOn)

capitalize (c:cs) = toUpper c : cs

prettyCaps = concatMap capitalize . splitOn "-"

prettyCamel s = let (w:ws) = splitOn "-" s in w ++ concatMap capitalize ws

Works as expected:

>> prettyCaps "foo-bar-example"
FooBarExample
>> prettyCamel "foo-bar-example"
fooBarExample

answered Jan 21, 2014 at 18:19

Chris Taylor

47.6k15 gold badges113 silver badges156 bronze badges

Comments

Sebastian Redl · Accepted Answer · 2014-01-21 18:10:32Z

1

foldr1 (++) is available in the standard library; it's called concat. splitString is available in the text library for the data type Text as split (== '-'), in the MissingH library as split "-", in the split library as splitWhen (== '-'), or in the bytestring library for data type ByteString as split (== '-').

answered Jan 21, 2014 at 18:10

Sebastian Redl

73.9k8 gold badges137 silver badges177 bronze badges

Collectives™ on Stack Overflow

Learning Haskell: string transformations

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related