From: Aran Donohue
Hi Haskell-Cafe,
Consider a data type such as
data Binding = Binding Var (Either Value [Value])
representing a variable bound either to a fixed value or that has a list of possible values.
I'd like to perform an operation on say, the fixed-value members of a list of bindings. Data.Either has "partitionEithers"---I'd essentially like to use partitionEithers, but in a way that it "peeks" into the value field of the binding. For the sake of argument, let's say I can't or can't modify Binding to move the Either to the outside.
I think that partitionEithers is leading you down the wrong trail. If what you want to do is modify some values inside the binding, I would start with this:
mapVal :: (Either Value [Value] -> Either Value [Value]) -> Binding -> Binding mapVal f (Binding v e) = Binding v (f e)
mapLeft :: (a -> b) -> Either a c -> Either b c mapLeft f = either (Left . f) Right
-- mapRight is just fmap, but for symmetry mapRight :: (b -> c) -> Either a b -> Either a c mapRight = fmap
modifyFixed :: (Value -> Value) -> Binding -> Binding modifyFixed f b = mapVal (mapLeft f) b
modifyList :: ([Value] -> [Value]) -> Binding -> Binding modifyList f b = mapVal (mapRight f) b
-- note that modifyFixed and modifyList have very nice point-free representations -- modifyFixed = mapVal . mapLeft -- modifyList = mapVal . mapRight
Now to apply this to a list:
modifyFixedBindings :: (Value -> Value) -> [Binding] -> [Binding] modifyFixedBindings f binds = map (modifyFixed f) binds -- or point-free modifyFixedBindings' = map . modifyFixed
In my opinion, this would be more idiomatic if Binding were polymorphic:
data Binding' k v = Binding' k v
instance Functor (Binding' k) where fmap f (Binding' k v) = Binding' k (f v)
type Binding2 = Binding' Var (Either Value [Value])
now mapVal is just fmap, and these functions are:
modifyFixed2 :: (Val -> Val) -> [Binding2] -> [Binding2] modifyFixed2 = fmap . fmap . mapLeft
modifyList2 :: ([Val] -> [Val]) -> [Binding2] -> [Binding2] modifyList2 = fmap . fmap . mapRight
I've typed out all the steps for clarity, but to be honest, I wouldn't bother with the Fixed and List variants, unless you're going to use them frequently. I would do just:
mapVals :: (Either Value [Value] -> Either Value [Value]) -> [Binding] -> [Binding] mapVals f = map (\(Binding var val) -> Binding var (f val))
and leave it at that, using "mapVals" with the "either" function when necessary. I would consider making Binding polymorphic, though, so you can write the Functor instance. You may also want to look at Data.Traversable. Cheers, John