[Haskell-cafe] Help

Daniel Patterson lists.haskell at dbp.mm.st
Sat Jun 25 00:22:59 CEST 2011

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.haskell at 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 at haskell.org
> -- 
> Поздрави,
> Стоян Пеев

More information about the Haskell-Cafe mailing list