clash-prelude-1.8.4: Clash: a functional hardware description language - Prelude library

Copyright | (C) 2018 QBayLogic B.V.
License | BSD2 (see the file LICENSE)
Maintainer | Christiaan Baaij <christiaan.baaij@gmail.com>
Safe Haskell | Trustworthy
Language | Haskell2010

Clash.Hidden

Contents

- OverloadedLabels

Description

Hidden arguments

Synopsis

- type Hidden (x :: Symbol) a = IP x a
- expose :: forall (x :: Symbol) a r. (Hidden x a => r) -> a -> r
- fromLabel :: forall (x :: Symbol) a. Hidden x a => a

# Documentation

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

Expand

`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 #

Arguments

:: forall (x :: Symbol) a r. (Hidden x a => r) | Function with a `Hidden` argument
-> a | Function with the `Hidden` argument exposed
-> r |

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

# OverloadedLabels

fromLabel :: forall (x :: Symbol) 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