Hello, everyone!

I want to call one function (or the same but with a special argument, no matter) if a type instantiates some type-class or another - if not. I know that it's easy in languages like D, Java, possible C++ - we can specialize templates more generic or less generic and to restrict its parameters with class/interface implementation/extending (there are special keywords/type operators for it, used in generics/templates signatures). So, I suppose Haskell can do the same. But as it turned out, this is not so easy for Haskell :(

I found these useful links:

• https://stackoverflow.com/questions/26303353/can-multiple-dispatch-be-achieved-in-haskell-with-pattern-matching-on-type-class
• https://wiki.haskell.org/GHC/AdvancedOverlap

So, I wrote something like this (this example is compiling and works as I expect, you need `mustache` and `network-uri` packages). Goal is to substitute type in special way for HTML template and for text template if type implements a special interface (for deterministic substitution). Otherwise default substitution will be used. Actually, this code allows usage of not only HTML/text templates... OK, here it is:

{-# LANGUAGE EmptyDataDecls         #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses  #-}
{-# LANGUAGE OverloadedStrings      #-}
{-# LANGUAGE ScopedTypeVariables    #-}
{-# LANGUAGE TypeFamilies           #-}
{-# LANGUAGE UndecidableInstances   #-}

import           Data.Semigroup      ((<>))
import qualified Data.Text           as T
import           Network.URI
import qualified Text.Mustache.Types as MUT


type Link = (T.Text, URI) -- caption and URL, for example


-- |Converts a type to substitutable to Mustache template entity based on 'SubTo' template selector.
-- @sub@ must be ignored in implementation
class ToMustaches sub a where
  toMustaches :: sub -> a -> SubTo -> MUT.Value

-- |Substituted to HTML either to text
data SubTo = ToHtml | ToText

-- |Deterministic substitution
data DetSub
-- |Universal substitution
data UniSub

-- |Substitution predicate: it's determined uniquely for type
class SubPred a sub | a -> sub

-- TODO rename ToMustaches' (ToMustaches' ?)
class ToMustaches' a where
  toMustaches' :: a -> SubTo -> MUT.Value
instance (SubPred a sub, ToMustaches sub a) => ToMustaches' a where
  toMustaches' a to = toMustaches (undefined::sub) a to

-- See:
-- * https://stackoverflow.com/questions/36913922/how-to-resolve-overlapping-instance
-- * https://stackoverflow.com/questions/26303353/can-multiple-dispatch-be-achieved-in-haskell-with-pattern-matching-on-type-class
instance {-# OVERLAPS #-} (sub ~ UniSub) => SubPred a sub

-- 'Link' can be substituted deterministically
instance SubPred Link DetSub
instance ToMustaches DetSub Link where
  toMustaches _ (_, url)   ToText = MUT.String $ T.pack $ show url
  toMustaches _ (cap, url) ToHtml = MUT.String ("<a href=\"" <> (T.pack $ show url) <> "\">" <> cap <> "</a>")

-- |All other types which does not implements 'ToMustaches' default instance transforms them to string w/ 'Show'
instance Show a => ToMustaches UniSub a where
  toMustaches _ a _ = MUT.String $ T.pack $ show a

-------------------------------------------------------------------
main :: IO ()
main = do
  let
    uri = URI "http:" (Just $ URIAuth "" "wikipedia.org" "") "" "" ""
    lnk = ("wikipedia", uri)::Link
    txt = "Hello world"::T.Text
    n = 444::Int
  print $ toMustaches' lnk ToText
  print $ toMustaches' lnk ToHtml
  print $ toMustaches' txt ToHtml
  print $ toMustaches' n ToText

I don't know am I understand correctly the Haskell solution but this looks close to explained in the Haskell Wiki (case 1). But in all cases I see problem: always I need not only to implement this special interface but to "say" that a type implements special (deterministic) substitution, see:

instance SubPred Link DetSub

This means that clients of this code must "implements" 2 instances: 1) of ToMustaches and 2) of SubPred (with DetSub as last type param). This is terrible and no such thing  in other languages! So, my question is: is a simple way to avoid it?

===

Best regards, Paul