First I am using WinHugs.

that's the code i made so far but it's still not working:

http://hpaste.org/48318


Error:
ERROR file:.\kursovazadacha.hs:36 - Type error in explicitly typed binding
*** Term           : p
*** Type           : [String] -> [a]
*** Does not match : [String] -> Int


I'm still breaking down somewhere ...



2011/6/25 Daniel Patterson <lists.hask...@dbp.mm.st>:
> what haskell compiler are you using? And what does the "include" line do?
>
> That does not look like a GHC error message (the only compiler I'm familiar 
> with), but it seems like it is saying that you should not have the extra 
> newlines between the function type signature and declaration. - that's only 
> my guess, based on the assumption that the whitespace is being converted to a 
> syntax with explicit semilcolon line terminations.
>
> now, looking at the actual code, the type of the parse function is [a] -> 
> [a]. This means that you can parse a list of anything into a list of 
> anything, which doesnt make much sense. This should probably be [String] -> 
> [String]  (you are parsing a list of strings to a list of strings, yes?). Now 
> the base case of parse (the first case) makes sense, but look at the second 
> case. parse is being given a list of elements (which you have used pattern 
> matching to decompose, but the whole argument, (x:xs), is a list of 
> elements). You are then passing that, unchanged, to eval. This means that 
> eval must take the same type. Does it? how would you apply eval to each 
> element in that list, instead of just applying it to the whole list?
>
> On Jun 24, 2011, at 4:31 PM, Stoyan Peev wrote:
>
>> I found the library myself, and i already put the code in that site:
>>
>> http://hpaste.org/48277
>>
>>
>>
>> That's what i have tried to do for making the task by calling the one
>> string function by another one:
>>
>> include kursovazadacha
>>
>> parse :: [a] -> [a]
>>
>> parse [] = []
>>
>> parse (x:xs) = eval (x:xs)
>>
>>
>> The error from the compiler:
>>
>> ERROR file:.\list.hs:3 - Syntax error in declaration (unexpected `;',
>> possibly due to bad layout)
>>
>>
>> On Fri, Jun 24, 2011 at 11:20 PM, Daniel Patterson
>> <lists.hask...@dbp.mm.st> wrote:
>>> What have you tried to do in order to make it work for the list, and what 
>>> error results? What is confusing about the error message? More generally, 
>>> how could you transform an operation on a single string into one that does 
>>> the same thing to a list of strings? You've probably talked about higher 
>>> order functions in your class - would any of the common ones (filter, map, 
>>> foldr) be helpful here? Would any encapsulate what you are trying to do?
>>>
>>>  If you include these kinds of things, I think you'll find this community 
>>> to be very helpful; without that (showing what your thought process is, why 
>>> it isn't working, what seems confusing about what the haskell compiler is 
>>> telling you, etc), you are not going to get help here. People here are very 
>>> friendly and willing to help people learn; this is not a place to come to 
>>> get an assignment finished :)
>>>
>>> Also, could you put the library you are using (I'm assuming that this is 
>>> provided by your university) and the code on somewhere like hpaste.org, so 
>>> that the formatting is not messed up by email, and it is syntax highlighted?
>>>
>>> On Jun 24, 2011, at 3:57 PM, Stoyan Peev wrote:
>>>
>>>> Hello all,
>>>>
>>>> I am experiencing some issues to do my course task in university.
>>>>
>>>> I have to write a calculator- function in Haskell. The function
>>>> argument is a list of strings and also form such list, as each string
>>>> of the argument made definite action:
>>>> - If the string has the form of an arithmetic _expression_ - calculate
>>>> this _expression_. The string result becomes part of the list-result.
>>>> If the _expression_ contains a variable which is not assigned value,
>>>> the result is displayed "undefined".
>>>> - If the string has the form- Name = value calculated from the last
>>>> _expression_ is assigned to the variable with the corresponding name
>>>> in the list, and in the result list is formed a string with type
>>>> - If there is not a calculated _expression_ to be assigned to form a
>>>> string "no value".
>>>> - If the string is non-blank, but there is a species different from
>>>> the above two case, form the string "error".
>>>> - If the string is empty, incl. when it contains only spaces, in the
>>>> result there is not form a string.
>>>>
>>>> Expressions consist of integers without sign variables, operations +
>>>> (Addition), - (subtraction), * (multiplication) and / (divide) and
>>>> parentheses. Where no brackets, the operations are performed from left
>>>> to right, but * and / precede the + and -. Implementation of any
>>>> operation gives integer; in the division rejected the fractional part,
>>>> if any.
>>>> Variables have names of one letter - from the Latin small letter. In
>>>> the beginning, end or between the elements of each row can have spaces
>>>> - they are irrelevant to its correctness.
>>>> Example: the list-argument
>>>> ["3 +7 / 2" "2 + x", "= s", "2 * s +4", "", "2 + +4 / 5]
>>>> function should provide a result-list
>>>> ["6", "undefined", "s = 6", "16", "error"].
>>>>
>>>>
>>>> I say another person have the same task, but he didn't do anything. I
>>>> started doing this task myself but i get stuck in the middle. Then i
>>>> started searching for something that could help me and find out you :)
>>>>
>>>> The code i have written so far uses the library file "Parsing.lhs"
>>>> but what i have written is taking those actions that i already
>>>> described, only for a string. I cannot modify it to work for list of
>>>> string, and complete the whole task.
>>>>
>>>> I'll be glad to finish the task myself, but i am going to need some help.
>>>>
>>>> Here is the code i have already written:
>>>>
>>>>
>>>> import Parsing
>>>>
>>>> expr                          :: Parser Int
>>>> expr                          =  do t <- term
>>>>                                    do symbol "+"
>>>>                                       e <- expr
>>>>                                       return (t+e)
>>>>                                      +++ do symbol "-"
>>>>                                             e <- expr
>>>>                                             return (t-e)
>>>>                                      +++ return t
>>>> term                          :: Parser Int
>>>> term                          =  do f <- factor
>>>>                                    do symbol "*"
>>>>                                       t <- term
>>>>                                       return (f * t)
>>>>                                      +++ do symbol "/"
>>>>                                             t <- term
>>>>                                             return (f-t)
>>>>                                      +++ return f
>>>> factor                        :: Parser Int
>>>> factor                        =  do symbol "("
>>>>                                    e <- expr
>>>>                                    symbol ")"
>>>>                                    return e
>>>>                                  +++ natural
>>>> eval                          :: String -> Int
>>>> eval xs                       =  case (parse expr xs) of
>>>>                                    [(n,[])]  -> n
>>>>                                    [(_,out)] -> error ("undefined")
>>>>                                    []        -> error "error"
>>>>
>>>>
>>>>
>>>> Thanks all in advance :)
>>>>
>>>> --
>>>> Best Wishes
>>>> Stoyan Peev
>>>>
>>>> _______________________________________________
>>>> Haskell-Cafe mailing list
>>>> Haskell-Cafe@haskell.org
>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>
>>>
>>
>>
>>
>> --
>> Поздрави,
>> Стоян Пеев
>
>



-- 
Поздрави,
Стоян Пеев

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Reply via email to