X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FTyCon.lhs;h=e6366bea2b01d9b2f9ff10fc938b984f5128cb82;hb=a385f0af5ea320a18d580f6a36c59c55b3516efd;hp=cf2de8986ab85dd2a4687487d6f973f6b93b5eff;hpb=13cd965d80be5c25dc54534a833df39ab7aa7a12;p=ghc-hetmet.git diff --git a/compiler/types/TyCon.lhs b/compiler/types/TyCon.lhs index cf2de89..e6366be 100644 --- a/compiler/types/TyCon.lhs +++ b/compiler/types/TyCon.lhs @@ -11,18 +11,22 @@ module TyCon( PrimRep(..), tyConPrimRep, + primRepSizeW, AlgTyConRhs(..), visibleDataCons, TyConParent(..), SynTyConRhs(..), isFunTyCon, isUnLiftedTyCon, isProductTyCon, - isAlgTyCon, isDataTyCon, isNewTyCon, isClosedNewTyCon, isSynTyCon, - isClosedSynTyCon, isPrimTyCon, + isAlgTyCon, isDataTyCon, + isNewTyCon, unwrapNewTyCon_maybe, + isSynTyCon, isClosedSynTyCon, isOpenSynTyCon, + isPrimTyCon, + isEnumerationTyCon, isGadtSyntaxTyCon, isOpenTyCon, assocTyConArgPoss_maybe, isTyConAssoc, setTyConArgPoss, isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity, - isRecursiveTyCon, newTyConRep, newTyConRhs, newTyConCo_maybe, + isRecursiveTyCon, newTyConRhs, newTyConEtadRhs, newTyConCo_maybe, isHiBootTyCon, isSuperKindTyCon, isCoercionTyCon_maybe, isCoercionTyCon, isImplicitTyCon, @@ -76,6 +80,7 @@ import PrelNames import Maybes import Outputable import FastString +import Constants \end{code} %************************************************************************ @@ -181,7 +186,7 @@ data TyCon tyConName :: Name, tyConArity :: Arity, coKindFun :: [Type] -> (Type,Type) - } -- INVARAINT: coKindFun is always applied to exactly 'arity' args + } -- INVARIANT: coKindFun is always applied to exactly 'arity' args -- E.g. for trans (c1 :: ta=tb) (c2 :: tb=tc), the coKindFun returns -- the kind as a pair of types: (ta,tc) @@ -204,19 +209,22 @@ data AlgTyConRhs -- The constructor represents an open family without a fixed right hand -- side. Additional instances can appear at any time. - -- + -- + -- These are introduced by either a top level decl: + -- data T a :: * + -- or an assoicated data type decl, in a class decl: + -- class C a b where + -- data T b :: * + | OpenTyCon { - otArgPoss :: Maybe [Int], + otArgPoss :: Maybe [Int] -- Nothing <=> top-level indexed type family -- Just ns <=> associated (not toplevel) family -- In the latter case, for each tyvar in the AT decl, 'ns' gives the -- position of that tyvar in the class argument list (starting from 0). -- NB: Length is less than tyConArity iff higher kind signature. - otIsNewtype :: Bool - -- is a newtype (rather than data type)? - } | DataTyCon { @@ -235,31 +243,20 @@ data AlgTyConRhs -- = the representation type of the tycon -- The free tyvars of this type are the tyConTyVars - nt_co :: Maybe TyCon, -- The coercion used to create the newtype + nt_co :: Maybe TyCon, -- A CoercionTyCon used to create the newtype -- from the representation - -- optional for non-recursive newtypes + -- Optional for non-recursive newtypes -- See Note [Newtype coercions] + -- Invariant: arity = #tvs in nt_etad_rhs; + -- See Note [Newtype eta] + -- Watch out! If any newtypes become transparent + -- again check Trac #1072. - nt_etad_rhs :: ([TyVar], Type) , + nt_etad_rhs :: ([TyVar], Type) -- The same again, but this time eta-reduced -- hence the [TyVar] which may be shorter than the declared -- arity of the TyCon. See Note [Newtype eta] - - nt_rep :: Type -- Cached: the *ultimate* representation type - -- By 'ultimate' I mean that the top-level constructor - -- of the rep type is not itself a newtype or type synonym. - -- The rep type isn't entirely simple: - -- for a recursive newtype we pick () as the rep type - -- newtype T = MkT T - -- - -- This one does not need to be eta reduced; hence its - -- free type variables are conveniently tyConTyVars - -- Thus: - -- newtype T a = MkT [(a,Int)] - -- The rep type is [(a,Int)] - -- NB: the rep type isn't necessarily the original RHS of the - -- newtype decl, because the rep type looks through other - } -- newtypes. + } visibleDataCons :: AlgTyConRhs -> [DataCon] visibleDataCons AbstractTyCon = [] @@ -267,31 +264,41 @@ visibleDataCons OpenTyCon {} = [] visibleDataCons (DataTyCon{ data_cons = cs }) = cs visibleDataCons (NewTyCon{ data_con = c }) = [c] --- Both type classes as well as family instances imply implicit type --- constructors. These implicit type constructors refer to their parent +-- Both type classes as well as family instances imply implicit +-- type constructors. These implicit type constructors refer to their parent -- structure (ie, the class or family from which they derive) using a type of -- the following form. We use `TyConParent' for both algebraic and synonym -- types, but the variant `ClassTyCon' will only be used by algebraic tycons. --- + data TyConParent = NoParentTyCon -- An ordinary type constructor has no parent. | ClassTyCon -- Type constructors representing a class dictionary. - Class + Class -- INVARIANT: the classTyCon of this Class is the current tycon | FamilyTyCon -- Type constructors representing an instance of a type TyCon -- The type family [Type] -- Instance types; free variables are the tyConTyVars - -- of this TyCon + -- of the current TyCon (not the family one) + -- INVARIANT: the number of types matches the arity + -- of the family tycon TyCon -- A CoercionTyCon identifying the representation -- type with the type instance family. -- c.f. Note [Newtype coercions] + + -- -- E.g. data intance T [a] = ... -- gives a representation tycon: -- data :R7T a = ... -- axiom co a :: T [a] ~ :R7T a -- with :R7T's algTcParent = FamilyTyCon T [a] co +okParent :: Name -> TyConParent -> Bool -- Checks invariants +okParent _ NoParentTyCon = True +okParent tc_name (ClassTyCon cls) = tyConName (classTyCon cls) == tc_name +okParent _ (FamilyTyCon fam_tc tys _co_tc) = tyConArity fam_tc == length tys + +-------------------- data SynTyConRhs = OpenSynTyCon Kind -- Type family: *result* kind given (Maybe [Int]) -- for associated families: for each tyvars in @@ -308,7 +315,6 @@ data SynTyConRhs Note [Newtype coercions] ~~~~~~~~~~~~~~~~~~~~~~~~ - The NewTyCon field nt_co is a a TyCon (a coercion constructor in fact) which is used for coercing from the representation type of the newtype, to the newtype itself. For example, @@ -366,12 +372,53 @@ Source code: w2 :: Foo T w2 = MkFoo (\(MkT x) -> case w1 of MkFoo f -> f x) -After desugaring, and discading the data constructors for the newtypes, +After desugaring, and discarding the data constructors for the newtypes, we get: w2 :: Foo T w2 = w1 And now Lint complains unless Foo T == Foo [], and that requires T==[] +This point carries over to the newtype coercion, because we need to +say + w2 = w1 `cast` Foo CoT + +so the coercion tycon CoT must have + kind: T ~ [] + and arity: 0 + + +Note [Indexed data types] (aka data type families) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + See also Note [Wrappers for data instance tycons] in MkId.lhs + +Consider + data family T a + + data instance T (b,c) where + T1 :: b -> c -> T (b,c) + +Then + * T is the "family TyCon" + + * We make "representation TyCon" :R1T, thus: + data :R1T b c where + T1 :: forall b c. b -> c -> :R1T b c + + * It has a top-level coercion connecting it to the family TyCon + + axiom :Co:R1T b c : T (b,c) ~ :R1T b c + + * The data contructor T1 has a wrapper (which is what the source-level + "T1" invokes): + + $WT1 :: forall b c. b -> c -> T (b,c) + $WT1 b c (x::b) (y::c) = T1 b c x y `cast` sym (:Co:R1T b c) + + * The representation TyCon :R1T has an AlgTyConParent of + + FamilyTyCon T [(b,c)] :Co:R1T + + %************************************************************************ %* * @@ -408,6 +455,22 @@ data PrimRep | AddrRep -- a pointer, but not to a Haskell value | FloatRep | DoubleRep + deriving( Eq, Show ) + +instance Outputable PrimRep where + ppr r = text (show r) + +-- Size of a PrimRep, in words +primRepSizeW :: PrimRep -> Int +primRepSizeW IntRep = 1 +primRepSizeW WordRep = 1 +primRepSizeW Int64Rep = wORD64_SIZE `quot` wORD_SIZE +primRepSizeW Word64Rep= wORD64_SIZE `quot` wORD_SIZE +primRepSizeW FloatRep = 1 -- NB. might not take a full word +primRepSizeW DoubleRep= dOUBLE_SIZE `quot` wORD_SIZE +primRepSizeW AddrRep = 1 +primRepSizeW PtrRep = 1 +primRepSizeW VoidRep = 0 \end{code} %************************************************************************ @@ -435,6 +498,17 @@ mkFunTyCon name kind -- This is the making of a TyCon. Just the same as the old mkAlgTyCon, -- but now you also have to pass in the generic information about the type -- constructor - you can get hold of it easily (see Generics module) +mkAlgTyCon :: Name + -> Kind + -> [TyVar] + -> [PredType] + -> AlgTyConRhs + -> [Id] + -> TyConParent + -> RecFlag + -> Bool + -> Bool + -> TyCon mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn = AlgTyCon { tyConName = name, @@ -445,15 +519,17 @@ mkAlgTyCon name kind tyvars stupid rhs sel_ids parent is_rec gen_info gadt_syn algTcStupidTheta = stupid, algTcRhs = rhs, algTcSelIds = sel_ids, - algTcParent = parent, + algTcParent = ASSERT( okParent name parent ) parent, algTcRec = is_rec, algTcGadtSyntax = gadt_syn, hasGenerics = gen_info } +mkClassTyCon :: Name -> Kind -> [TyVar] -> AlgTyConRhs -> Class -> RecFlag -> TyCon mkClassTyCon name kind tyvars rhs clas is_rec = mkAlgTyCon name kind tyvars [] rhs [] (ClassTyCon clas) is_rec False False +mkTupleTyCon :: Name -> Kind -> Arity -> [TyVar] -> DataCon -> Boxity -> Bool -> TyCon mkTupleTyCon name kind arity tyvars con boxed gen_info = TupleTyCon { tyConUnique = nameUnique name, @@ -470,6 +546,7 @@ mkTupleTyCon name kind arity tyvars con boxed gen_info -- as primitive, but *lifted*, TyCons for now. They are lifted -- because the Haskell type T representing the (foreign) .NET -- type T is actually implemented (in ILX) as a thunk +mkForeignTyCon :: Name -> Maybe FastString -> Kind -> Arity -> TyCon mkForeignTyCon name ext_name kind arity = PrimTyCon { tyConName = name, @@ -483,16 +560,20 @@ mkForeignTyCon name ext_name kind arity -- most Prim tycons are lifted +mkPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon mkPrimTyCon name kind arity rep = mkPrimTyCon' name kind arity rep True +mkVoidPrimTyCon :: Name -> Kind -> Arity -> TyCon mkVoidPrimTyCon name kind arity = mkPrimTyCon' name kind arity VoidRep True -- but RealWorld is lifted +mkLiftedPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon mkLiftedPrimTyCon name kind arity rep = mkPrimTyCon' name kind arity rep False +mkPrimTyCon' :: Name -> Kind -> Arity -> PrimRep -> Bool -> TyCon mkPrimTyCon' name kind arity rep is_unlifted = PrimTyCon { tyConName = name, @@ -504,6 +585,7 @@ mkPrimTyCon' name kind arity rep is_unlifted tyConExtName = Nothing } +mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon mkSynTyCon name kind tyvars rhs parent = SynTyCon { tyConName = name, @@ -515,6 +597,7 @@ mkSynTyCon name kind tyvars rhs parent synTcParent = parent } +mkCoercionTyCon :: Name -> Arity -> ([Type] -> (Type,Type)) -> TyCon mkCoercionTyCon name arity kindRule = CoercionTyCon { tyConName = name, @@ -524,6 +607,7 @@ mkCoercionTyCon name arity kindRule } -- Super kinds always have arity zero +mkSuperKindTyCon :: Name -> TyCon mkSuperKindTyCon name = SuperKindTyCon { tyConName = name, @@ -557,7 +641,7 @@ isUnLiftedTyCon _ = False isAlgTyCon :: TyCon -> Bool isAlgTyCon (AlgTyCon {}) = True isAlgTyCon (TupleTyCon {}) = True -isAlgTyCon other = False +isAlgTyCon _ = False isDataTyCon :: TyCon -> Bool -- isDataTyCon returns True for data types that are definitely @@ -567,30 +651,30 @@ isDataTyCon :: TyCon -> Bool -- True for all @data@ types -- False for newtypes -- unboxed tuples -isDataTyCon tc@(AlgTyCon {algTcRhs = rhs}) +-- type families +-- +-- NB: for a data type family, T, only the *instance* tycons are +-- get an info table etc. The family tycon does not. +-- Hence False for OpenTyCon +isDataTyCon (AlgTyCon {algTcRhs = rhs}) = case rhs of - OpenTyCon {} -> not (otIsNewtype rhs) + OpenTyCon {} -> False DataTyCon {} -> True NewTyCon {} -> False AbstractTyCon -> False -- We don't know, so return False isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity -isDataTyCon other = False +isDataTyCon _ = False isNewTyCon :: TyCon -> Bool -isNewTyCon (AlgTyCon {algTcRhs = rhs}) = - case rhs of - OpenTyCon {} -> otIsNewtype rhs - NewTyCon {} -> True - _ -> False -isNewTyCon other = False - --- This is an important refinement as typical newtype optimisations do *not* --- hold for newtype families. Why? Given a type `T a', if T is a newtype --- family, there is no unique right hand side by which `T a' can be replaced --- by a cast. --- -isClosedNewTyCon :: TyCon -> Bool -isClosedNewTyCon tycon = isNewTyCon tycon && not (isOpenTyCon tycon) +isNewTyCon (AlgTyCon {algTcRhs = NewTyCon {}}) = True +isNewTyCon _ = False + +unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon) +unwrapNewTyCon_maybe (AlgTyCon { tyConTyVars = tvs, + algTcRhs = NewTyCon { nt_co = mb_co, + nt_rhs = rhs }}) + = Just (tvs, rhs, mb_co) +unwrapNewTyCon_maybe _ = Nothing isProductTyCon :: TyCon -> Bool -- A "product" tycon @@ -605,9 +689,9 @@ isProductTyCon tc@(AlgTyCon {}) = case algTcRhs tc of DataTyCon{ data_cons = [data_con] } -> isVanillaDataCon data_con NewTyCon {} -> True - other -> False + _ -> False isProductTyCon (TupleTyCon {}) = True -isProductTyCon other = False +isProductTyCon _ = False isSynTyCon :: TyCon -> Bool isSynTyCon (SynTyCon {}) = True @@ -620,13 +704,16 @@ isSynTyCon _ = False isClosedSynTyCon :: TyCon -> Bool isClosedSynTyCon tycon = isSynTyCon tycon && not (isOpenTyCon tycon) +isOpenSynTyCon :: TyCon -> Bool +isOpenSynTyCon tycon = isSynTyCon tycon && isOpenTyCon tycon + isGadtSyntaxTyCon :: TyCon -> Bool isGadtSyntaxTyCon (AlgTyCon { algTcGadtSyntax = res }) = res -isGadtSyntaxTyCon other = False +isGadtSyntaxTyCon _ = False isEnumerationTyCon :: TyCon -> Bool isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res -isEnumerationTyCon other = False +isEnumerationTyCon _ = False isOpenTyCon :: TyCon -> Bool isOpenTyCon (SynTyCon {synTcRhs = OpenSynTyCon _ _}) = True @@ -659,44 +746,45 @@ isTupleTyCon :: TyCon -> Bool -- get spat into the interface file as tuple tycons, so I don't think -- it matters. isTupleTyCon (TupleTyCon {}) = True -isTupleTyCon other = False +isTupleTyCon _ = False isUnboxedTupleTyCon :: TyCon -> Bool isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity) -isUnboxedTupleTyCon other = False +isUnboxedTupleTyCon _ = False isBoxedTupleTyCon :: TyCon -> Bool isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity -isBoxedTupleTyCon other = False +isBoxedTupleTyCon _ = False +tupleTyConBoxity :: TyCon -> Boxity tupleTyConBoxity tc = tyConBoxed tc isRecursiveTyCon :: TyCon -> Bool isRecursiveTyCon (AlgTyCon {algTcRec = Recursive}) = True -isRecursiveTyCon other = False +isRecursiveTyCon _ = False isHiBootTyCon :: TyCon -> Bool -- Used for knot-tying in hi-boot files isHiBootTyCon (AlgTyCon {algTcRhs = AbstractTyCon}) = True -isHiBootTyCon other = False +isHiBootTyCon _ = False isForeignTyCon :: TyCon -> Bool -- isForeignTyCon identifies foreign-imported type constructors isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True -isForeignTyCon other = False +isForeignTyCon _ = False isSuperKindTyCon :: TyCon -> Bool isSuperKindTyCon (SuperKindTyCon {}) = True -isSuperKindTyCon other = False +isSuperKindTyCon _ = False isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type,Type)) isCoercionTyCon_maybe (CoercionTyCon {tyConArity = ar, coKindFun = rule}) = Just (ar, rule) -isCoercionTyCon_maybe other = Nothing +isCoercionTyCon_maybe _ = Nothing isCoercionTyCon :: TyCon -> Bool isCoercionTyCon (CoercionTyCon {}) = True -isCoercionTyCon other = False +isCoercionTyCon _ = False -- Identifies implicit tycons that, in particular, do not go into interface -- files (because they are implicitly reconstructed when the interface is @@ -732,11 +820,11 @@ tcExpandTyCon_maybe, coreExpandTyCon_maybe Type, -- Body type (not yet substituted) [Type]) -- Leftover args --- For the *typechecker* view, we expand synonyms only +-- For the *typechecker* view, we expand (closed) synonyms only tcExpandTyCon_maybe (SynTyCon {tyConTyVars = tvs, synTcRhs = SynonymTyCon rhs }) tys = expand tvs rhs tys -tcExpandTyCon_maybe other_tycon tys = Nothing +tcExpandTyCon_maybe _ _ = Nothing --------------- -- For the *Core* view, we expand synonyms only as well @@ -767,7 +855,7 @@ expand tvs rhs tys tyConHasGenerics :: TyCon -> Bool tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg -tyConHasGenerics other = False -- Synonyms +tyConHasGenerics _ = False -- Synonyms tyConDataCons :: TyCon -> [DataCon] -- It's convenient for tyConDataCons to return the @@ -778,7 +866,7 @@ tyConDataCons_maybe :: TyCon -> Maybe [DataCon] tyConDataCons_maybe (AlgTyCon {algTcRhs = DataTyCon { data_cons = cons }}) = Just cons tyConDataCons_maybe (AlgTyCon {algTcRhs = NewTyCon { data_con = con }}) = Just [con] tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con] -tyConDataCons_maybe other = Nothing +tyConDataCons_maybe _ = Nothing tyConFamilySize :: TyCon -> Int tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) = @@ -786,13 +874,11 @@ tyConFamilySize (AlgTyCon {algTcRhs = DataTyCon {data_cons = cons}}) = tyConFamilySize (AlgTyCon {algTcRhs = NewTyCon {}}) = 1 tyConFamilySize (AlgTyCon {algTcRhs = OpenTyCon {}}) = 0 tyConFamilySize (TupleTyCon {}) = 1 -#ifdef DEBUG tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other) -#endif tyConSelIds :: TyCon -> [Id] tyConSelIds (AlgTyCon {algTcSelIds = fs}) = fs -tyConSelIds other_tycon = [] +tyConSelIds _ = [] algTyConRhs :: TyCon -> AlgTyConRhs algTyConRhs (AlgTyCon {algTcRhs = rhs}) = rhs @@ -805,9 +891,9 @@ newTyConRhs :: TyCon -> ([TyVar], Type) newTyConRhs (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rhs = rhs }}) = (tvs, rhs) newTyConRhs tycon = pprPanic "newTyConRhs" (ppr tycon) -newTyConRep :: TyCon -> ([TyVar], Type) -newTyConRep (AlgTyCon {tyConTyVars = tvs, algTcRhs = NewTyCon { nt_rep = rep }}) = (tvs, rep) -newTyConRep tycon = pprPanic "newTyConRep" (ppr tycon) +newTyConEtadRhs :: TyCon -> ([TyVar], Type) +newTyConEtadRhs (AlgTyCon {algTcRhs = NewTyCon { nt_etad_rhs = tvs_rhs }}) = tvs_rhs +newTyConEtadRhs tycon = pprPanic "newTyConEtadRhs" (ppr tycon) newTyConCo_maybe :: TyCon -> Maybe TyCon newTyConCo_maybe (AlgTyCon {algTcRhs = NewTyCon { nt_co = co }}) = co @@ -859,23 +945,23 @@ maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr \begin{code} isClassTyCon :: TyCon -> Bool isClassTyCon (AlgTyCon {algTcParent = ClassTyCon _}) = True -isClassTyCon other_tycon = False +isClassTyCon _ = False tyConClass_maybe :: TyCon -> Maybe Class tyConClass_maybe (AlgTyCon {algTcParent = ClassTyCon clas}) = Just clas -tyConClass_maybe other_tycon = Nothing +tyConClass_maybe _ = Nothing isFamInstTyCon :: TyCon -> Bool isFamInstTyCon (AlgTyCon {algTcParent = FamilyTyCon _ _ _ }) = True isFamInstTyCon (SynTyCon {synTcParent = FamilyTyCon _ _ _ }) = True -isFamInstTyCon other_tycon = False +isFamInstTyCon _ = False tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type]) tyConFamInst_maybe (AlgTyCon {algTcParent = FamilyTyCon fam instTys _}) = Just (fam, instTys) tyConFamInst_maybe (SynTyCon {synTcParent = FamilyTyCon fam instTys _}) = Just (fam, instTys) -tyConFamInst_maybe other_tycon = +tyConFamInst_maybe _ = Nothing tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon @@ -883,7 +969,7 @@ tyConFamilyCoercion_maybe (AlgTyCon {algTcParent = FamilyTyCon _ _ coe}) = Just coe tyConFamilyCoercion_maybe (SynTyCon {synTcParent = FamilyTyCon _ _ coe}) = Just coe -tyConFamilyCoercion_maybe other_tycon = +tyConFamilyCoercion_maybe _ = Nothing \end{code}