Hello!
The problem is that it's impossible to infer the SomeClass instance from the
type SomeRole. If you do "print role", which instance should it use?
I can think of two ways around it:
-- 1. (dummy parameter)
--
data SomeRole a = Role1 | Role2 | Role3 deriving Show
class SomeClass a where
role :: SomeRole a
data Foo = Foo
data Bar = Bar
instance SomeClass Foo where role = Role1
instance SomeClass Bar where role = Role2
main = do
print (role :: SomeRole Foo)
print (role :: SomeRole Bar)
-- 2. (dummy argument)
--
data SomeRole = Role1 | Role2 | Role3 deriving Show
class SomeClass a where
role :: a -> SomeRole
data Foo = Foo
data Bar = Bar
instance SomeClass Foo where role _ = Role1
instance SomeClass Bar where role _ = Role2
main = do
print (role (undefined :: Foo))
print (role (undefined :: Bar))
--
On Sunday 10 May 2009 15:21:39 Belka wrote:
> Hello, communion people!
>
> I seek for your advice in a matter, where it's really hard for me to
> determine a good programming style.
> Here's the problem. I'm generalizing multiple authorization procedures to
> one, using class definition. (if of any interest, the code is in the end.)
> The problem essense is folowing:
>
> data SomeRole = Role1 | Role2 | Role3
>
> class SomeClass a b c | a -> b, c where
> f1 :: ...
> f2 :: ...
> ...
> fn :: ...
> role :: SomeRole -- <-- here is the problem
>
> I want to have a fuctional dependency from a type "a" on a value of *role*,
> so that I could easily "inspect" the *role* from within any other class
> members.
> Is it possible? Or do I rougly violate some style traditions?
>
> Some real code using wished feature:
> ---
> data AuthentificationPurpose = JustValidateInput | JustGenerateForOutput |
> ValidateInputAndGenerateForOutput
> type AuthSucceded = Bool
>
> class AuthentificationStructure t_env t_realInput t_assumption t_keySet |
> t_realInput -> t_assumptionInput, t_keySet where
> authentificationPurpose :: AuthentificationPurpose
> makeAssumption :: t_env -> t_realInput -> IO (Either ErrorMessage
> t_assumption)
> makeFinalKeySet :: (t_realInput, t_assumption) -> t_keySet
> validateRealKeySet_with_Assumed :: t_realInput -> t_keySet -> Maybe
> ErrorMessage
> tryLogTheValidKey :: t_env -> (t_realInput, t_assumption)
> -> IO (Maybe ErrorMessage)
> tryLogTheAuthTry :: t_env -> (t_realInput, t_assumption,
> AuthSucceded) -> IO (Maybe ErrorMessage)
>
> authentificate :: AuthentificationStructure t_env t_realInput
> t_assumptionInput t_keySet => t_env -> t_businessInput -> IO (Either
> ErrorMessage (t_assumption, t_keySet))
> authentificate env realInput = do err_or_assumption <- makeAssumption env
> realInput
> case err_or_assumption of
> Left err_msg -> return $ Left "Error!
> Assumption maker failed. Lower level error message: " ++ err_msg
> Just assumption -> do
> key_set <-
> makeFinalKeySet (realInput, assumption)
> err_or_keyset1 <- case
> authentificationPurpose of
>
> JustGenerateForOutput -> return $ Right key_set
>
> JustValidateInput -> do
>
> mb_failure <- validateRealKeySet_with_Assumed t_realInput key_set
>
> case mb_failure of
>
> Just err_msg -> return $ Left "Error! Invalid set of auth keys. Lower level
> error message: " ++ err_msg
>
> Nothing -> return $ Right key_set
>
> ValidateInputAndGenerateForOutput
> err_or_keyset2 <- case
> err_or_keyset1 of
>
> Left err_msg -> return err_or_keyset1
>
> Right key_set -> do
>
> mb_failure <- tryLogTheValidKey env (realInput, assumption)
>
> case mb_failure of
>
> Just err_msg -> return $ Left "Error! Could not log valid key. Lower level
> error message: " ++ err_msg
>
> Nothing -> return err_or_keyset1
> mb_failure <-
> tryLogTheAuthTry env (realInput, assumption, isRight err_or_keyset2)
> case mb_failure of
> Just err_msg1 -> case
> err_or_keyset2 of
>
> Left err_msg2 -> return $ Left ("1. " ++ err_msg2 ++ "\n2. " ++ err_msg1)
>
> Right _ -> return $ Left err_msg1
> Nothing -> case
> err_or_keyset2 of
>
> Left err_msg -> return $ Left err_msg
>
> Right key_set -> return $ Right (assumption, key_set)
> -
>
> Best regar
