Question

I recently started learning Haskell and I’m trying to rewrite something I did for an interview in python in Haskell. I’m trying to convert a string from camel case to underscore separated (“myVariableName” -> “my_variable_name”), and also throw an error if the first character is upper case.

Here’s what I have:

import qualified Data.Char as Char

translate_java :: String -> String
translate_java xs = translate_helper $ enumerate xs
    where 
        translate_helper [] = []
        translate_helper ((a, num):xs)
            | num == 1 and Char.isUpper a = error "cannot start with upper"
            | Char.isUpper a              = '_' : Char.toLower a : translate_helper xs
            | otherwise                   = a : translate_helper xs


enumerate :: (Num b, Enum b) => [a] -> [(a,b)]
enumerate xs = zip xs [1..]

I realize It’s pretty likely I’m going about this in a weird way, and I’d love advice about better ways to implement this, but I’d like to get this to compile as well. Here’s the error I’m getting now:

Prelude> :r
[1 of 1] Compiling Main             ( translate.hs, interpreted )

translate.hs:4:20:
    No instance for (Num
                       (([Bool] -> Bool) -> (Char -> Bool) -> Char -> t))
      arising from a use of `translate_helper' at translate.hs:4:20-35
    Possible fix:
      add an instance declaration for
      (Num (([Bool] -> Bool) -> (Char -> Bool) -> Char -> t))
    In the first argument of `($)', namely `translate_helper'
    In the expression: translate_helper $ enumerate xs
    In the definition of `translate_java':
        translate_java xs
                         = translate_helper $ enumerate xs
                         where
                             translate_helper [] = []
                             translate_helper ((a, num) : xs)
                                                | num == 1 and Char.isUpper a
                                                = error "cannot start with upper
"
                                                | Char.isUpper a
                                                = '_' : Char.toLower a : transla
te_helper xs
                                                | otherwise = a : translate_help
er xs
Failed, modules loaded: none.

Any explanation of what’s going on here would be great. I really don’t understand where “(Num (([Bool] -> Bool) -> (Char -> Bool) -> Char -> t))” is coming from. I’d think the type declaration for translate_helper would be something like [(a,b)] -> [a]?

Answer 1

The problem is this:

| num == 1 and Char.isUpper a = ...

and is not an infix operator; rather it is a function:

and :: [Bool] -> Bool

So it is interpreting 1 and Char.isUpper a as applying three arguments to the “function” 1. Use && instead.

The error message comes from the way numerals are interpreted. A numeral, say, 1 is actually polymorphic; the specific type it gets depends on the type that is needed. That’s why you can say x+1 and it will work whether x is an integer or a double or whatever. So the compiler inferred that the type of 1 needs to be a three-argument function, and then tried to find a numeric type matching that so it could convert 1 into that type (and, naturally, failed).