EQ MEANING MANUAL
In fact, in the absence of the manual type signature, ghci infers: Prelude> :t isequal This is a perfectly fine definition of isequal, but the type constraints that I have manually put on it are way stronger than they have to. Unless you use arithmetic operations or similar things, you will most likely find that your functions already work for all Eq a.Īs a simpler example that may explain the concept: Let's say we want to write a function isequal that checks for equality (slightly useless, but hey): isequal :: Integer -> Integer -> Bool
EQ MEANING CODE
You probably don't have to change a lot: Try removing the explicit type signatures from your code and ask ghci about the type that it would infer from your code ( :l yourfile.hs and then :t deleteAll_list_comp). What you implemented (rather, what you think you implemented) is a function that works only on lists of Integers, what the assignment wants you to do is create one that works on lists of all types provided they are equality-comparable (so that your function will also work on lists of booleans or strings). All standard Haskell types except for IO (the type for dealing with input and >output) and functions are a part of the Eq typeclass." Any type where it makes >sense to test for equality between two values of that type should be a member of the Eq >class. The Eq typeclass provides an interface for testing for equality. The >type of those two values must be a member of the Eq class (this was the class constraint). We can read the previous type declaration like this: the >equality function takes any two values that are of the same type and returns a Bool. Everything before the => symbol is >called a class constraint. Why does this generate an error but deleteAll_list_comp :: (Eq a) => a -> -> ĭeleteAll_list_comp toDelete ls = [x | x symbol. Lacks an accompanying binding" which makes no sense to me seeing as how I did bind the requirements properly, didn't I? From my small experience, (a:as) counts as a list while extracting the first element from it. This gives me a "The type signature for deleteAll_list_rec If(toDelete = a) then delete_list_rec toDelete as However, I still am running into a problem with this code. I understand now that really it is only asking for two parameters as opposed to three. How do I go about interpreting and implementing the methods using these parameters? What I mean is, what exactly are the parameters to begin this makes it very clear. However, I don't understand the point of this as all Ints are naturally comparable. As Google has told me, (Eq a) merely explains to Haskell that a is a type that is comparable. However, I do it with these parameters: deleteAll_list_comp :: Integer -> -> ĭeleteAll_list_rec :: (Integer -> Bool) -> -> įor my assignment, however, my required parameters are deleteAll_list_comp :: (Eq a) => a -> -> ĭeleteAll_list_rec :: (Eq a) => a -> -> I can create the function easily enough, both with list comprehension and list recursion. I need to create a function of two parameters, an Int and a, that returns a new with all occurrences of the first parameter removed.
0 kommentar(er)
