*laughs evilly...*

got this error:

test/ExampleSpec.hs:9:30: error:
    • Variable not in scope:
        factor :: Integer -> Integer -> Integer -> [Integer]
    • Perhaps you meant ‘factors’ (line 11)
  |
9 |        where und = unduplic (factor 2 n n)
  |                              ^^^^^^

yep, it works, thanks :-)

Haskell: get this error when submitting:

.../Kata/Test.hs:25:85:
    Not in scope: `b'

That's just something I wanted to write because I found this funny since I'm a pretty stupid person :-)

This comes from the Functor instance on functions defined as

instance Functor ((->) a) where
  fmap = (.)

implying that fmap fmap fmap == (.) . (.) in this context.

At that time, Codewars used to have only python 2, and with python 2, 276 / 30 = 9.

Well, other languages use a NULL value when there is no solution, which translates to Nothing in haskell.

Also (and this is a very personnal opinion), this kata being clearly oriented to beginners, it would be great to show them good practice and make them become accustomed to the Maybe type :-)

Wouldn't this be more "haskellish" to have sumAndMultiply :: Int -> Int -> Maybe (Int, Int) ?

Nope, because in a functor instance, f :: a -> b. If you simply do map f toks, you will try to apply f on Token a, this will not type check. You need fmap f to make this work.

Sure, that would be

instance Functor Token where
  fmap f (Token a) = Token (f a)
  fmap f (Brackets toks) = Brackets (map (fmap f) toks)

However, I am not sure you can make an applicative out of this. I think any instance would violate the homomorphism law.

Since you have neither a Functor nor an Applicative instance for your Token type (which is impossible, since Token :: * and should be * -> *), you have no choice but to create a function like

insert :: Token -> Token -> Token
insert tok (Brackets xs) = Brackets (tok : xs)
insert _ _ = error "should not happen"

Then with this function, you can do something like

a = Just (Token "foo")
b = Just (Brackets [Token "bar"])
c = insert <$> a <*> b

With currying, you could even create a function

insertA :: Applicative f => f Token -> f Token -> f Token
insertA = liftA2 insert

d = insertA a b

And thank you for this challenge, I enjoyed solving it :-)

Nope, it does not :) Just try the lambda function with an example like "1a2b3c".