What is the Haskell reverse function expected in this code? - function

Question

I'm writing a small Haskell exercise, it is should shift some elements within a list, similar to a Caesar cipher, the code is already working, the code is below.
module Lib (shift, cipherEncode, cipherDecode ) where
import Data.Char
import Data.List
import Data.Maybe
abcdata :: [Char]
abcdata = ['a','b','c','d','e','f','g']
iabcdata :: [Char]
iabcdata = ['g','f','e','d','c','b','a']
shift :: Char -> Int -> Char
shift l n = if (n >= 0)
then normalShift l n
else inverseShift l (abs n)
normalShift :: Char -> Int -> Char
normalShift l n = shifter l n abcdata
inverseShift :: Char -> Int -> Char
inverseShift l n = shifter l n reverse(abcdata) -- This is the line
charIdx :: Char -> [Char] -> Int
charIdx target xs = fromJust $ elemIndex target xs
shifter :: Char -> Int -> [Char] -> Char
shifter l n xs = if (n < length (xs))
then
picker ((charIdx l xs) + n) xs
else
picker ((charIdx l xs) + (n `mod` length (xs))) xs
picker :: Int -> [Char] -> Char
picker n xs = if n < length xs
then
xs!!n
else
xs!!(n `mod` length (xs))
The question I have is regarding the line
inverseShift l n = shifter l n reverse(abcdata)
If I change it by
inverseShift l n = shifter l n iabcdata
it works fine
also, when I do reverse(abcdata) == iabcdata it is True
but when I leave the reverse in the code I get the following error
* Couldn't match expected type `[Char] -> Char'
with actual type `Char'
* The function `shifter' is applied to four arguments,
but its type `Char -> Int -> [Char] -> Char' has only three
In the expression: shifter l n reverse (abcdata)
In an equation for `inverseShift':
inverseShift l n = shifter l n reverse (abcdata)
|
21 | inverseShift l n = shifter l n reverse(abcdata)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* Couldn't match expected type `[Char]'
with actual type `[a0] -> [a0]'
* Probable cause: `reverse' is applied to too few arguments
What am I doing wrong by calling shifter with reverse(abcdata) ?

Answer 1

That's not how parentheses work in Haskell. The way you wrote it, reverse and abcdata would both be arguments to shifter, but you want abcdata to be an argument to reverse. Do shifter l n (reverse abcdata) instead of shifter l n reverse(abcdata).

Answer 2

What am I doing wrong by calling shifter with reverse(abcdata) ?
The answer is in the message:
* Couldn't match expected type `[Char] -> Char'
with actual type `Char'
* The function `shifter' is applied to four arguments,
but its type `Char -> Int -> [Char] -> Char' has only three
In the expression: shifter l n reverse (abcdata)
In an equation for `inverseShift':
inverseShift l n = shifter l n reverse (abcdata)
Repeat,
In an equation for `inverseShift':
inverseShift l n = shifter l n reverse (abcdata)
~~~~~~~~~~~~~ -- mind the gap!
That is how your expression was read by Haskell. And this is how it was written by you:
|
21 | inverseShift l n = shifter l n reverse(abcdata)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
So you haven't in fact called shifter with reverse(abcdata).
You called it with reverse and (abcdata) (as well l and n), as is also explained in the other answer.