Hi Joe - I've cc'ed back to list...
I'm supposing from what you've said that only DataConst1 & DataConst2
have ids - so I've made a type synonym VId
type VId = Int
data TestData = DataConst1 VId String
| DataConst2 VId Int
| DataConst3 Sting String
| DataConst4 String Int
If both DataConst1 & DataConst2 have VId's the you right - you have to
pattern match for both:
setVid_to_4 :: TestData -> TestData
setVid_to_4 (DataConst1 _ y) = DataConst1 4 y
setVid_to_4 (DataConst2 _ y) = DataConst2 4 y
setVid_to_4 var = var
If all the cases of TestData had a VId e.g.:
data TestData = DataConst1 VId String
| DataConst2 VId Int
| DataConst3 VId Sting String
| DataConst4 Vid String Int
... then you could factor out VId to get these two data types
data FactoredTD = FactoredTD VId TD
data TD = DC1 String
| DC2 Int
| DC3 String String
| DC4 String Int
setVid_to_4 :: FactoredTD -> FactoredTD
setVid_to_4 (FactoredTD _ y) = FactoredTD 4 y
This factoring transformation is quite common.
For your particular data type you could factor the other way:
data TestDataX = DataConst1_or_2 VId (Either String Int)
| DataConst3 Sting String
| DataConst4 String Int
setVid_to_4 :: TestDataX -> TestDataX
setVid_to_4 (DataConst1_or_2 _ y) = DataConst1_or_2 4 y
setVid_to_4 y = y
However this factoring is quite horrible - I can't think of anywhere
where I've seen it.
Generally I wouldn't be too concerned about redundancy in pattern
matching. If its easy to consistently name all the constructors in an
algebraic data type, then that's a strong indication that you've put
it into a good form.
If you're still taxed by duplicate pattern matching you can then write
projection and modification functions to do it once and once only:
-- Has to return a Maybe as DC3 and DC4 have no ID
getVId :: TestData -> Maybe VId
getVid (DataConst1 iden _) = Just iden
getVid (DataConst2 iden _) = Just iden
getVid _ = Nothing
-- note - uses an update function that accesses the original value
-- rather than a simple replace
--
updateVid :: (Vid -> Vid) -> TestData -> TestData
updateVid f (DataConst1 iden y) = DataConst1 (f iden) y
updateVid f (DataConst2 iden y) = DataConst2 (f iden) y
updateVid f var = var
incrementVid :: TestData -> TestData
incrementVid = updateVid (\x -> x+1)
Best wishes
Stephen
On 8 March 2010 12:19, Joe Fox
Hi Guys,
First thanks for all yours inputs.
Actually test is just a simple function , actually my actual function is pretty complex and huge ...
let me redefine Test function , i guess i took a bad example which created lot of confusion
the type of the test functions will be something like this , (i don't have any ambiguity on type of the function, )
test:: TestData -> TestData
My question is like is there any way i can match multiple pattern in a function statement .
like this (I know this doesnt work , but just trying to explain whats on my mind)
test var@(DataConst1 x y) == var@(DataConst2 x y) = var{id=4} -- let's say id is the record holder for first record test var@(_) = var --- any for other two its returns the same
the working code would be like test var@(DataConst1 x y) = var{id=4} test var@(DataConst2 x y) = var{id=4} --- I want these two lines in one line, because the logic is same test var@(_) = var
some thing of this sort. I hope i didnt add to the confusion
Thanks Joe