On 08/03/12 16:19, Christopher Done wrote:

‘Ello.

Is there a generalization of this operator? It's all over the place, it's basically

(!) :: (Monad m, Indexed collection index value) => index -> container -> m value

We have `(!!)` on lists, `(!)` on maps, vectors, json objects, … (doesn't seem there's one for bytestring)

(Though I seem to recall the monadic return value being frowned upon but I don't recall why.)

Thoughts?

Ciao!

Ciao! It doesn't exist as far as I know, but a "Map" typeclass can be easily envisioned, e.g.: {-# LANGUAGE MultiParamTypeClasses , FunctionalDependencies , FlexibleInstances #-} module MapClass (MapClass(..)) where import Data.Map (Map) import qualified Data.Map as Map import Data.Hashable (Hashable) import Data.HashMap.Lazy (HashMap) import qualified Data.HashMap.Lazy as HashMap import qualified Data.List as List class MapClass m k v | m -> k, m -> v where empty :: m lookup :: k -> m -> Maybe v insert :: k -> v -> m -> m instance Ord k => MapClass [(k, v)] k v where empty = [] lookup = List.lookup insert k v = ((k, v) :) instance Ord k => MapClass (Map k v) k v where empty = Map.empty lookup = Map.lookup insert = Map.insert instance (Hashable k, Eq k) => MapClass (HashMap k v) k v where empty = HashMap.empty lookup = HashMap.lookup insert = HashMap.insert

Ok, this should suit your needs better, without functional dependencies as a bonus: {-# LANGUAGE TypeFamilies, ScopedTypeVariables, FlexibleInstances #-} module IxClass (IxClass(..)) where import Data.Map (Map) import qualified Data.Map as Map import Data.Hashable (Hashable) import Data.HashMap.Lazy (HashMap) import qualified Data.HashMap.Lazy as HashMap import qualified Data.List as List class IxClass a where type Ix a :: * type Value a :: * index :: Ix a -> a -> Maybe (Value a) (!) :: IxClass a => a -> Ix a -> (Value a) a ! k = case index k a of Just v -> v Nothing -> error "IxClass.(!): index not found" instance IxClass [a] where type Ix [a] = Int type Value [a] = a index _ [] = Nothing index 0 (x : _) = Just x index n (_ : xs) = index (n - 1) xs instance Ord k => IxClass (Map k v) where type Ix (Map k v) = k type Value (Map k v) = v index = Map.lookup instance (Hashable k, Eq k) => IxClass (HashMap k v) where type Ix (HashMap k v) = k type Value (HashMap k v) = v index = HashMap.lookup

(Though I seem to recall the monadic return value being frowned upon but I don't recall why.)

The type signature that you wrote is very generic and doesn't help in introducing effects while retrieving the indexed value, which I imagine is what you wanted to do. I guess you could define a type family for the monad type as well, e.g.: type family Index f type family IndexMonad f :: * -> * class Functor f => Indexed f where index :: Index f -> f a -> (IndexMonad f) (Maybe a) Francesco.