clash-prelude-1.2.3: CAES Language for Synchronous Hardware - Prelude library
Copyright(C) 2018 QBayLogic B.V.
LicenseBSD2 (see the file LICENSE)
MaintainerChristiaan Baaij <>
Safe HaskellTrustworthy



Hidden arguments



type Hidden (x :: Symbol) a = IP x a Source #

A value reflected to, or hiding at, the Constraint level

e.g. a function:

f :: Hidden "foo" Int
  => Bool
  -> Int
f = ...

has a normal argument of type Bool, and a hidden argument called "foo" of type Int. In order to apply the Int argument we have to use the expose function, so that the hidden argument becomes a normal argument again.

Original implementation


Hidden used to be implemented by:

class Hidden (x :: Symbol) a | x -> a where
  hidden :: a

which is equivalent to IP, except that IP has magic inference rules bestowed by GHC so that there's never any ambiguity. We need these magic inference rules so we don't end up in type inference absurdity where asking for the type of an type-annotated value results in a no-instance-in-scope error.

expose Source #


:: forall x a r. (Hidden x a => r)

Function with a Hidden argument

-> a -> r

Function with the Hidden argument exposed

Expose a Hidden argument so that it can be applied normally, e.g.

f :: Hidden "foo" Int
  => Bool
  -> Int
f = ...

g :: Int -> Bool -> Int
g = expose @"foo" f


fromLabel :: forall x a. Hidden x a => a Source #

Using -XOverloadedLabels and -XRebindableSyntax, we can turn any value into a hidden argument using the #foo notation, e.g.:

f :: Int -> Bool -> Int
f = ...

g :: Hidden "foo" Bool
  => Int -> Int
g i = f i #foo