Questions[haskell]

I am doing a programming exercise in Haskell, in which I give some values ​​in a list, for example [1, 2, 2, 3, 4] and it should be as follows [1, 4, 3, 4]. So far the program works without problems for me with the following code:

sustituirSumando [x,y] 
              | x==y = [x+y]
              | otherwise = [x,y]
sustituirSumando [x,y,z] 
              | x==y = [x+y,z]   
              | y==z = [x,y+z]
              |otherwise = [x,y,z] 
sustituirSumando (x:y:xs) 
               | x==y = (x+y) : sustituirSumando (xs)                
               | otherwise = x: sustituirSumando (y:xs)

Where I don't know how to proceed is in the following supposed example [1, 2, 2, 4, 5] here the list should be as follows [1, 8, 5] but in my code it remains [1, 4, 4, 5]. Thanks in advance.

We have the following function:

repartir [a] -> ([a],[a])

So partition should partition the main list into two lists by taking the elements like this:

repartir [1,2,3,4,5]

---> ([1,3,5],[2,4])

repartir "hola"

---> ("hl","oa")

We can only import:import Data.List

Greetings and thank you

In an article I read, written by Martin Odersky ( "Unifying Functional and Object-Oriented Programming with Scala" , Communications of the ACM, Vol. 57 No. 4, Pages 76-86), in the conclusions he indicated the following:

Another important abstraction mechanism in Scala is implicit parameters that let one emulate the essential capabilities of Haskell's type classes.

I understand how implicit arguments work in scala and I know haskell's type classes . But I don't quite understand how to "emulate" type classes in scala using implicit arguments.

Does anyone have any scala examples that can illustrate this mechanism?

I confess that I am falling in love with Haskell, I am giving hard to the lists and the functions that can be applied:

Prelude> let list = [1,2,3,4,5]
Prelude> head list
1
Prelude> tail list
[2,3,4,5]
Prelude> init list
[1,2,3,4]
Prelude> last list
5
Prelude> take 2 list
[1,2]
Prelude> drop 3 list
[4,5]
Prelude> reverse list 
[5,4,3,2,1]

Wonder, I understand that the functions that return a list (such as tail, init, reverse, etc.) do not affect the list used as a parameter, that is, the original list listhas not been modified and a copy (?) of that list is returned:

Prelude> list
[1,2,3,4,5]

What I tried to do is something very simple:

Prelude> let list = reverse list

In my head I expected it to now listcontain [5,4,3,2,1], but trying to see what it contains just crashes the interpreter:

Prelude> list
(el cursor se queda acá y no hace nada)

Why is this happening?

I am starting to learn Haskell with the book Learn You a Haskell for Great Good! , I come from using Python which is an imperative language. I am using the interpreter ghciand ran into the following:

Prelude> 5 * -3

<interactive>:2:1:    
    Precedence parsing error
        cannot mix `*' [infixl 7] and prefix `-' [infixl 6] in the same infix expression

From the error I understand that I cannot mix *with -in the expression, in the book they do not explain the reason why it does not work, they only recommend using parentheses:

Prelude> 5 * (-3)
-15

It occurs to me that it -is treated as a function and that is why when enclosing it in parentheses it is evaluated first before multiplying. So I tried the following:

Prelude> -(5)
-5
Prelude> +(5)

<interactive>:9:1: parse error on input `+'

Well now I'm confused. why is it not possible to multiply a negative number without the need to use parentheses?