On Thu, Jan 8, 2009 at 1:49 AM, minh thu
I'd like to simply write, like above,
b = B a a where a = A [C]
or, maybe,
b = B label a a where a = A label [C]
The question is : how can label be different each time ?
Haskell is pure, so I can answer this precisely: obviously you cannot. Sharing is *not* observable in Haskell, because it breaks referential transparency, a very important property. So what I meant by hashing was, eg.: newtype Hash = ... data Foo = Foo Hash Int [Foo] mkFoo :: Int -> [Foo] -> Foo mkFoo n xs = Foo (hash (show n ++ concatMap (\(Foo h _ _) -> show h))) n xs hash :: String -> Hash hash = ... -- some cryptographic hash function Probably going through Strings is not the smartest way, but you get the idea? Then when two Foos have the same hash, you have odds of 1/2^64 or whatever that they are the same object. You could also compare directly without hashes, but that is slower for large data structures (more correct though -- hash comparisons always gave me the creeps). I just saw your reply to the StableName suggestion. I should warn you -- you should use this information only for optimization internal to your program. If you use it for observable effects, e.g. generating code or writing to a file[1], you are writing *bad haskell*, and you will not only lose the benefits of Haskell's purity, but you will be bitten by the unpredictable zeal of the optimizer. Luke [1] Unless you read the file back into the data structure, where the sharing is once again not observable.