Documentation

Constraint for classes forbidding type presence based on predicate defined by TPredicateSym.

Not just a type alias in order to be able to partially apply it (e.g. in Each).

Reports errors when a type does not satisfy predicate:

>>> () :: ForbidT PSOp TOperation => ()
...
... Type `operation` found in
... 'TOperation
... is not allowed in this scope
...
>>> () :: ForbidT PSContract (TContract TUnit) => ()
...
... Type `contract` found in
... 'TContract 'TUnit
... is not allowed in this scope
...
>>> () :: ForbidT PSTicket (TTicket TUnit) => ()
...
... Type `ticket` found in
... 'TTicket 'TUnit
... is not allowed in this scope
...
>>> () :: ForbidT PSBigMap (TBigMap TUnit TUnit) => ()
...
... Type `big_map` found in
... 'TBigMap 'TUnit 'TUnit
... is not allowed in this scope
...
>>> () :: ForbidT PSSaplingState (TSaplingState Z) => ()
...
... Type `sapling_state` found in
... 'TSaplingState 'Z
... is not allowed in this scope
...
>>> () :: ForbidT PSNestedBigMaps (TBigMap TUnit (TBigMap TUnit TUnit)) => ()
...
... Nested `big_map`s found in
... 'TBigMap 'TUnit ('TBigMap 'TUnit 'TUnit)
... are not allowed
...

When the type is ambiguous or polymorphic, suggests adding the corresponding constraint:

>>> (const () :: ForbidOp t => f t -> ()) undefined
...
... Can't check if type
... t0
... contains `operation`. Perhaps you need to add
... ForbidT 'PSOp t0
... constraint? You can also try adding a type annotation.
...

This constraint implies ContainsT ~ False:

>>> :{
foo :: ForbidT p t => ContainsT p t :~: False
foo = Refl
:}

Type-level symbol for type predicates used in ContainsT

Abstracts multiple ForbidT constraints. Accepts a constraint that will be suggested in an error message in case ContainsT gets stuck. This is used with scope constraints in Morley.Michelson.Typed.Scope.Internal.Scopes.

Class abstracting multiple ForbidT constraints.

This version accepts a custom error message displayed if ContainsT gets stuck. You likely want to use ForbidManyT, which sets this message.

It's a class and not a recursive type family because recursive type families take noticeably longer to compile.

This is a horrible hack designed to delay GHC's test for equality of ContainsT ... with False. Unfortunately, due to the use of incoherence, more type signatures will be required downstream. But the impact seems somewhat minimal in practice.

Given a list of TPredicateSym, pretty-print a list of corresponding type names. Uses TPredicateSymTypeName for a single type, separates the last two types with or, others with ,.

Doesn't do the oxford comma, because it's rather tricky to implement, and compilation types aren't great already.