GHC如何处理核心中的类型类和实例？

Question

I compiled the following Haskell code to core:

class FunClass a where
  functionInClass :: a -> ()

data MyData = MyData
data YourData = YourData

instance FunClass MyData where
  functionInClass a = ()
instance FunClass YourData where
  functionInClass a = ()

valueA :: ()
valueA = functionInClass MyData

valueB :: ()
valueB = functionInClass YourData

and got the following core bindings (I deleted some boilerplates that are irrelavant):

 $cfunctionInClass :: MyData -> ()
 [LclId]
 $cfunctionInClass = \ _ [Occ=Dead] -> break<3>() ()

 $fFunClassMyData [InlPrag=INLINE (sat-args=0)] :: FunClass MyData
 $fFunClassMyData
   = $cfunctionInClass
     `cast` (Sym (N:FunClass[0] <MyData>_N)
             :: Coercible (MyData -> ()) (FunClass MyData))

 $cfunctionInClass :: YourData -> ()
 [LclId]
 $cfunctionInClass = \ _ [Occ=Dead] -> break<2>() ()

 $fFunClassYourData [InlPrag=INLINE (sat-args=0)] :: FunClass YourData
 $fFunClassYourData
   = $cfunctionInClass
     `cast` (Sym (N:FunClass[0] <YourData>_N)
             :: Coercible (YourData -> ()) (FunClass YourData))

 valueA :: ()
 [LclIdX]
 valueA
   = break<1>() functionInClass @ MyData $fFunClassMyData MyData

 valueB :: ()
 [LclIdX]
 valueB
   = break<0>()
     functionInClass @ YourData $fFunClassYourData YourData

My questions are:

1. Why do the two cfunctionInClass share the same name? How do we tell them apart?

2. What does cast do exactly?

3. Is there anything related to typeclass/instance outside of mg_binds ModGuts ?

Answer 1

Without knowing (i) exactly which version of GHC, (ii) the exact ghc command line you used, and (iii) the full contents of the file you compiled, it's hard to duplicate the core output you're asking about, but here are some answers:

1) When generating your core, you probably supplied the flag -dsuppress-uniques , used some other flag that implied it, or maybe used an older version of GHC where it was the default. This flag causes GHC to suppress from the core output the little random suffixes used to create unique names. If you remove the flag or add an explicit -dno-suppress-uniques , you should see unique names like $cfunctionInClass_r1cH and $cfunctionInClass_r1dh .

2) Core is a typed language, and the function cast is used (extensively) to change the types of expressions. Note that it does not change the internal representation of the expression itself, so it can only be used to switch between types that have the same internal representation in memory.

You'll see casts all over the place for code that uses newtypes . For example the code:

newtype MyInt = MyInt Int
inc (MyInt n) = MyInt (n + 1)

creates the (unoptimized) core:

inc1 :: MyInt -> Int
inc1
  = \ (ds :: MyInt) ->
      + @ Int $fNumInt (ds `cast` (N:MyInt[0] :: MyInt ~R# Int)) (I# 1#)
inc :: MyInt -> MyInt
inc
  = inc1
    `cast` (<MyInt>_R ->_R Sym (N:MyInt[0])
            :: (MyInt -> Int) ~R# (MyInt -> MyInt))

with several casts.

The way cast works, the left hand side of the `cast` operator is a normal core term (eg, variable or other expression) representing the value whose type is being changed; the right hand side is something called a "coercion" which is a piece of evidence that the compiler constructs to prove that two types are representationally equivalent (ie, have the same in-memory representation and so can be safely coerced). For example, in my newtype example above, the coercion for the first cast:

N:MyInt[0] :: MyInt ~R# Int

is a coercion value N:MyInt[0] whose type is the representational equality ( ~R# ) of MyInt and Int . (Technically, N:MyInt[0] is a coercion type whose kind is the given representational equality, but that distinction doesn't really matter.) If you're familiar with the Curry-Howard isomorphism, where values can be considered proofs of their types, this is an example of this in action deep in GHC's guts -- the value/type N:MyInt[0] proves its type/kind, namely the representational equality of the newtype and its contents, which allows the cast to take place.

In your example, the cast:

$fFunClassMyData [InlPrag=INLINE (sat-args=0)] :: FunClass MyData
$fFunClassMyData
  = $cfunctionInClass
    `cast` (Sym (N:FunClass[0] <MyData>_N)
            :: Coercible (MyData -> ()) (FunClass MyData))

is a complex way of saying that GHC represents instance dictionaries for type classes having only one function much the same way it would represent a newtype containing a function of that type which is the same way it would represent the function value itself. Therefore, the function value $cfunctionInClass can be directly cast to a dictionary value.

However, if you added another function to your typeclass:

class FunClass a where
  functionInClass :: a -> ()
  anotherFunction :: a

the casts would disappear from the definition of the dictionaries, and they'd look more like what you'd expect:

$fFunClassMyData
$fFunClassMyData = C:FunClass $cfunctionInClass $canotherFunction

It's important to note that cast doesn't do anything in the final code. Once the core is converted to untyped STG and eventually CMM and assembly, the cast calls are optimized out, as they don't affect the values, they only modify compile-time types to satisfy the core typechecker. So, unless you're debugging GHC, you probably don't care about casts and should consider then no-ops. You can suppress some of the detail with -dsuppress-coercions (implied by -dsuppress-all ):

$fFunClassYourData = $cfunctionInClass1 `cast` <Co:3>

and just pretend x `cast` <Co:xxx> is exactly equivalent to x . In your example above, the dictionary is just the single instance function for the typeclass, so this is really the same up to coercible types as:

$fFunClassMyData = $cFunctionInClass

3) Sure. Additional class and instance information is stored in the mg_tcs and mg_insts fields of ModGuts , respectively. To a rough approximation, mg_binds contains the information needed for code generation while mg_tcs and mg_insts contain the information needed to generate the interface file.

Helpful references to GHC compiler code

ghc/compiler/coreSyn/PprCore.hs - Module for pretty-printing core. If you want to know where something in core comes from, this is it. (For example, ppr_expr add_par (Cast expr co) = ... is the code responsible for pretty printing `cast` operators.

ghc/compiler/coreSyn/CoreSyn.hs - The Expr type is the "core" of core. The constructor Cast (Expr b) Coercion represents a cast.

ghc/compiler/types/TycoRep.hs - The definition of Coercion is here.

ghc/compiler/main/HscTypes.hs - The definition of ModGuts and the "subsets" of fields CgGuts used for code generation and ModIface / ModDetails used for writing the interface file and linking.

ghc/compiler/main/TidyPgm.hs - Definition of the function tidyGuts , where ModGuts information is split into CgGuts for code generation and ModDetails , a cached version of ModIface kept in memory when compiling multiple modules and/or used to generate a full ModIface to write out to an interface file.