是否在某些定義的單一功能的情況下是不可能的？

Question

以下進口/語言編譯指示需要

{-# language FlexibleContexts, MultiParamTypeClasses, TypeSynonymInstances, FlexibleInstances, CPP #-} 
import Data.String.Conversions 

以下兩個功能typechecks細（*種）：

(++<>) :: (
    ConvertibleStrings a Text, 
    ConvertibleStrings b Text 
) 
    => a -> b -> Text 
a ++<> b = cs a <> cs b 

csappend :: (
    ConvertibleStrings a Text, 
    ConvertibleStrings b Text, 
    ConvertibleStrings Text c) 
    => a -> b -> c 
csappend a b = cs (a ++<> b) 

我試圖界定上述兩種功能作爲單個功能：

singleFunction :: (
    ConvertibleStrings a Text, 
    ConvertibleStrings b Text, 
    ConvertibleStrings Text c, 
    Monoid Text) => a -> b -> c 
singleFunction a b = cs (cs a <> cs b) 

---

*

xyz :: String 
xyz = do 
    let s = "test"      :: String 
    csappend (csappend s s :: String) s :: String -- this typechecks 
    csappend (csappend s s) s   :: String -- this does not typechecks 

---

這給了我一個錯誤（如下圖）。我不明白的錯誤的原因 - 類型的限制似乎是相同的，我不知道是否可能別的東西是錯誤的原因是什麼？

• Could not deduce (ConvertibleStrings a0 c) 
     arising from a use of ‘cs’ 
     from the context: (ConvertibleStrings a Text, 
         ConvertibleStrings b Text, 
         ConvertibleStrings Text c) 
     bound by the type signature for: 
        singleFunction :: (ConvertibleStrings a Text, 
             ConvertibleStrings b Text, ConvertibleStrings Text c) => 
            a -> b -> c 
     at /home/chris/Projects/Haskell/Hart/Hart.hs:(37,1)-(40,43) 
     The type variable ‘a0’ is ambiguous 
     Relevant bindings include 
     singleFunction :: a -> b -> c 
      (bound at /home/chris/Projects/Haskell/Hart/Hart.hs:41:1) 
     These potential instances exist: 
     instance [safe] ConvertibleStrings StrictText StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings StrictText String 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings String StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     ...plus one other 
     ...plus 21 instances involving out-of-scope types 
     (use -fprint-potential-instances to see them all) 
    • In the expression: cs (cs a <> cs b) 
     In an equation for ‘singleFunction’: 
      singleFunction a b = cs (cs a <> cs b) 

/home/chris/Projects/Haskell/Hart/Hart.hs:41:26: error: 
    • Could not deduce (ConvertibleStrings a a0) 
     arising from a use of ‘cs’ 
     from the context: (ConvertibleStrings a Text, 
         ConvertibleStrings b Text, 
         ConvertibleStrings Text c) 
     bound by the type signature for: 
        singleFunction :: (ConvertibleStrings a Text, 
             ConvertibleStrings b Text, ConvertibleStrings Text c) => 
            a -> b -> c 
     at /home/chris/Projects/Haskell/Hart/Hart.hs:(37,1)-(40,43) 
     The type variable ‘a0’ is ambiguous 
     Relevant bindings include 
     a :: a (bound at /home/chris/Projects/Haskell/Hart/Hart.hs:41:16) 
     singleFunction :: a -> b -> c 
      (bound at /home/chris/Projects/Haskell/Hart/Hart.hs:41:1) 
     These potential instances exist: 
     instance [safe] ConvertibleStrings StrictText StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings StrictText String 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings String StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     ...plus one other 
     ...plus 21 instances involving out-of-scope types 
     (use -fprint-potential-instances to see them all) 
    • In the first argument of ‘(<>)’, namely ‘cs a’ 
     In the first argument of ‘cs’, namely ‘(cs a <> cs b)’ 
     In the expression: cs (cs a <> cs b) 

/home/chris/Projects/Haskell/Hart/Hart.hs:41:26: error: 
    • Could not deduce (Monoid a0) arising from a use of ‘<>’ 
     from the context: (ConvertibleStrings a Text, 
         ConvertibleStrings b Text, 
         ConvertibleStrings Text c) 
     bound by the type signature for: 
        singleFunction :: (ConvertibleStrings a Text, 
             ConvertibleStrings b Text, ConvertibleStrings Text c) => 
            a -> b -> c 
     at /home/chris/Projects/Haskell/Hart/Hart.hs:(37,1)-(40,43) 
     The type variable ‘a0’ is ambiguous 
     These potential instances exist: 
     instance Monoid a => Monoid (IO a) -- Defined in ‘GHC.Base’ 
     instance Monoid Ordering -- Defined in ‘GHC.Base’ 
     instance Monoid Text -- Defined in ‘Data.Text’ 
     ...plus 8 others 
     ...plus 19 instances involving out-of-scope types 
     (use -fprint-potential-instances to see them all) 
    • In the first argument of ‘cs’, namely ‘(cs a <> cs b)’ 
     In the expression: cs (cs a <> cs b) 
     In an equation for ‘singleFunction’: 
      singleFunction a b = cs (cs a <> cs b) 

/home/chris/Projects/Haskell/Hart/Hart.hs:41:34: error: 
    • Could not deduce (ConvertibleStrings b a0) 
     arising from a use of ‘cs’ 
     from the context: (ConvertibleStrings a Text, 
         ConvertibleStrings b Text, 
         ConvertibleStrings Text c) 
     bound by the type signature for: 
        singleFunction :: (ConvertibleStrings a Text, 
             ConvertibleStrings b Text, ConvertibleStrings Text c) => 
            a -> b -> c 
     at /home/chris/Projects/Haskell/Hart/Hart.hs:(37,1)-(40,43) 
     The type variable ‘a0’ is ambiguous 
     Relevant bindings include 
     b :: b (bound at /home/chris/Projects/Haskell/Hart/Hart.hs:41:18) 
     singleFunction :: a -> b -> c 
      (bound at /home/chris/Projects/Haskell/Hart/Hart.hs:41:1) 
     These potential instances exist: 
     instance [safe] ConvertibleStrings StrictText StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings StrictText String 
      -- Defined in ‘Data.String.Conversions’ 
     instance [safe] ConvertibleStrings String StrictText 
      -- Defined in ‘Data.String.Conversions’ 
     ...plus one other 
     ...plus 21 instances involving out-of-scope types 
     (use -fprint-potential-instances to see them all) 
    • In the second argument of ‘(<>)’, namely ‘cs b’ 
     In the first argument of ‘cs’, namely ‘(cs a <> cs b)’ 
     In the expression: cs (cs a <> cs b) 

Answer 1

此定義不起作用，因爲編譯器無法推導出中間類型。 你答應編譯a和b可以轉換爲Text，但是當你調用調用的地方定義cs a結果類型，只有在現場調用編譯派生類型之後檢查約束。在這裏，你馬上就多態結果再打電話cs和GHC不知道你意味着什麼類型的。

singleFunction :: (
    ConvertibleStrings a Text, 
    ConvertibleStrings b Text, 
    ConvertibleStrings Text c, 
    Monoid Text) => a -> b -> c 
singleFunction a b = cs (cs a <> cs b) 

的情況下，有兩個功能的作品，因爲++<> explicityly在返回類型Text。

所以，如果你想使用Text作爲中間幺你應該更明確

singleFunction :: (
     ConvertibleStrings a Text, 
     ConvertibleStrings b Text, 
     ConvertibleStrings Text c) => a -> b -> c 
singleFunction a b = cs ((cs a <> cs b) :: Text)