Haskell中的数学函数是否有特定类型？

Question

I want to write a function that takes a mathematical function (/,x,+,-), a number to start with and a list of numbers. Then, it's supposed to give back a list.

The first element is the starting number, the second element the value of the starting number plus/minus/times/divided by the first number of the given list. The third element is the result of the previous result plus/minus/times/divided by the second result of the given list, and so on.

I've gotten everything to work if I tell the code which function to use but if I want to let the user input the mathematical function he wants, there are problems with the types. Trying :t (/) for example gives out Fractional a => a -> a -> a , but if you put that at the start of your types, it fails.

Is there a specific type to distinguish these functions (/,x,+,-)? Or is there another way to write this function succesfully?

prefix :: (Fractional a, Num a) => a -> a -> a -> a -> [a] -> [a]

prefix (f) a b = [a] ++ prefix' (f) a b


prefix' :: (Fractional a, Num a) => a -> a -> a -> a -> [a] -> [a]

prefix' (z) x [] = []

prefix' (z) x y = [x z (head y)] ++ prefix' (z) (head (prefix' (z) x y)) (tail y)

A right solution would be something like this:

prefix (-) 0 [1..5]

[0,-1,-3,-6,-10,-15]

Answer 1

Is there a specific type to distinguish these functions ( / , * , + , - )?

I don't see a reason to do this. Why is \\xy -> x+y considered "better" than \\xy -> x + y + 1 . Sure adding two numbers is something that most will consider more "pure". But it is strange to restrict yourself to a specific subset of functions. It is also possible that for some function \\xy -> fxy - 1 "happens" to be equal to (+) , except that the compiler can not determine that.

The type checking will make sure that one can not pass functions that operate on numbers, given the list contains strings, etc. But deliberately restricting this further is not very useful. Why would you prevent programmers to use your function for different purposes?

Or is there another way to write this function succesfully?

What you here describe is the scanl :: (b -> a -> b) -> b -> [a] -> [b] function. If we call scanl with scanl fz [x1, x2, ..., xn] , then we obtain a list [z, fz x1, f (fz x1) x2, ...] . scanl can be defined as:

scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl f = go
    where go z [] = [z]
          go z (x:xs) = z : go (f z x) xs

We thus first emit the accumulator (that starts with the initial value), and then "update" the accumulator to fzx with z the old accumulator, and x the head of the list, and recurse on the tail of the list.

Answer 2

If you want to restrict to these four operations, just define the type yourself:

data ArithOp = Plus | Minus | Times | Div

as_fun Plus = (+)
as_fun Minus = (-)
as_fun Times = (*)
as_fun Div = (/)