Help with Haskell

Question

I need some help if possible with the following problem....

atomsClause :: Clause ! [Atom] This function must take a Clause and return the set of Atoms of that Clause. Note that the set should not contain any duplicates.
atoms :: Formula![Atom] This function must take a Formula return the set of Atoms of a Formula. Note that the set should not contain any duplicates.
isLiteral :: Literal ! Clause ! Bool This function returns True if the given Literal can be found within the Clause.
flipSymbol :: Model ! Atom ! Model This function must take a Model and an Atom and flip the truth value of the atom in the model.

Here is the code:

module Algorithm where

import System.Random
import Data.Maybe
import Data.List

type Atom = String
type Literal = (Bool,Atom)
type Clause = [Literal]
type Formula = [Clause]
type Model = [(Atom, Bool)]
type Node = (Formula, ([Atom], Model))

atomsClause :: Clause -> [Atom]
atomsClause = undefined

atoms :: Formula -> [Atom]
atoms = undefined

isLiteral :: Literal -> Clause -> Bool
isLiteral = undefined

flipSymbol :: Model -> Atom -> Model
flipSymbol = undefined

Thank you.

I was thinking for the first one to write it like this......

atomsClause :: Clause -> [Atom]
atomsClause [(Bool,Atom)] =[a|(b,a)<-(Bool,Atom)]

...is this ok?

fuz · Accepted Answer · 2011-01-31 15:31:07Z

1

Your function is not right.

The pattern you match is simply a singleton list. You actually want to match the whole list to work with it. It could look like this:

atomsClause clauses = [a|(b,a)<-clauses]

What does this function does? Let's see... it takes the atom of each clause but there's no filtering. You can archive what you want using the nub function of Data.List. So your function looks like this:

atomsClause clauses = nub [a|(b,a)<-clauses]

Now, we can get rid of the comprehension using a map. We just map the function snd onto clauses:

atomsClause clauses = nub (map snd clauses)

And that's it! If you like it short, you can use this pointless function instead:

atomsClause = nub . map snd

answered Jan 31, 2011 at 15:31

fuz

94.7k27 gold badges216 silver badges391 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

TKFALS Over a year ago

I've done it like this and it returns ok....atomsClause xs =nub [a|(b,a)<-xs]...thank you for the reply...but I really need some advice for the second one...sorry ,but I haven't programmed in haskell for a long time

fuz Over a year ago

You may consider using concat, which collapses a list of two layers ([[a]]) into a list of one layer ([a]). Your function would be something like atoms f = atomsClause (concat f), or maybe atoms = atomsClause . concat. PS: You may accept my answer and vote it up. Just klick onto the green mark or the grey triangle upwards.

TKFALS Over a year ago

thank you so much for your answer ...I really want to take this opportunity and learn haskell....is it ok if I continue to ask you some questions.....for example the third one I was thinking of writing it like this isLiteral (b,a) cs = or[x==b && y==a|(x,y)<-cls],but I get the error Exception: Prelude.undefined

TKFALS Over a year ago

ah no...I solved the error ...andthe code is isLiteral (b,a) cs = or[x==b && y==a|(x,y)<-cs]..there was a mystake at the end

TKFALS Over a year ago

yes the code work:D...is there any way to write isLiteral (b,a) cs = or[x==b && y==a|(x,y)<-cs] as a shorter version....any advice for the last one?

|

Collectives™ on Stack Overflow

Help with Haskell

1 Answer 1

6 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Related