They are the arguments of the function, like in any other program (python def f(xs):). But sometimes it is possible to not write them, like here, if we can write the code in pure terms of functions combinations. It's hard to explain clearly (and I'm far from being comfortable in Haskell) but try to practice on easy katas and look at others solutions, try to reuse them... With Haskell installed on your computer you can run a very handy interpreter that allows to do tiny tests easily.

can someone explain this. Very new to haskell.
I am wondering why "xs" or any form of agruement is being used before the equal sign?

so cool!

Really cool approach. It's these kinds of code that made me learn haskell at first. Doing simple things the simple way

Yeah, that was silly of me

True, but just in case ;)

You mod 60 but you mod 10 the hard way ?!?

take 60 is unnecessary. Haskell is lazy.

No, siempre hay una forma mas redusida jajaj

Simple example: bimap (+ 10) (* 13) (7, 3) = (17, 39)

So, (bimap f g (a,b)) applies f to a, and g to b, while maintaining the tuple structure.

Another example, but with Either:

bimap (+ 10) (* 13) (Left 9)  = Left  19
bimap (+ 10) (* 13) (Right 2) = Right 26

Now, a clever trick is to apply join to bimap. It happens to be the case that join bimap applies the same function to both parts of a tuple:

join bimap (+2) (2,3) = (4,5)

The reason this works is due to the definition of join and the monad instance for functions (i.e. (->) r):

-- definitions
join x  :=  x >>= id
f >>= g :=  \r -> g (f r) r     -- (for functions only)

-- therefore:
join f  =  f >>= id
        =  \r -> id (f r) r
        =  \r -> f r r

-- specific to bimap:
join bimap = \r -> bimap r r

Thank you! It's so satisfying to lay things out his way :)

what is bimap?

Very nice, and well laid out!