enum-subset-generate

Generate an ADT being a subset of another ADT, and the corresponding mappings. https://github.com/0xd34df00d/enum-subset-generate#readme

Version on this page:0.1.0.0
LTS Haskell 12.22:0.1.0.0
Stackage Nightly 2018-12-12:0.1.0.0
Latest on Hackage:0.1.0.0

See all snapshots enum-subset-generate appears in

BSD3 licensed by Georg Rudoy
Maintained by 0xd34df00d@gmail.com

Module documentation for 0.1.0.0

There are no documented modules for this package.

enum-subset-generate

Build Status

Generates an ADT having a subset of constructors of some other ADT along with a pair of functions to map between the two.

Motivation

Consider implementing FFI bindings for a library. The lower level (directly mapping the C API onto Haskell) might expose an enumeration as an ADT, not all values of which might make sense for higher-level well-typed code. In this case the higher-level bindings might instead expose the generated ADT.

As an example, consider a parser library for a language like C++ or Java. A cursor pointing to a node in an AST might have a property like

enum AccessSpecifier {
    AS_Invalid,
    AS_Public,
    AS_Protected,
    AS_Private
};

AccessSpecifier getAccessSpecifier(Cursor*);

Access specifier doesn’t make much sense for a node representing a for-loop, hence the AS_Invalid member.

A low-level Haskell bindings library might translate this enum into

module Library.Bindings.FFI where

-- ...

data AccessSpecifier = Invalid
                     | Public
                     | Protected
                     | Private
                     deriving (Eq, Ord, Show)

getAccessSpecifier :: Cursor -> BindingsMonad AccessSpecifier

A more type-safe wrapper around this might introduce typed cursors and add a constraint to the function:

module Library.Bindings.Pure where

import qualified Library.Bindings.FFI as FFI

accessSpecifier :: HasAccessSpecifier t => Cursor t -> FFI.AccessSpecifier

so this accessSpecifier is guaranteed to always produce a non-Invalid result. But since it’s not explicitly stated in the types, the calling code will not be able to know about this, so the compiler’s case analyzer might still require handling the case of Invalid.

Using this library, one might instead just do

-- Generate an AccessSpecifier in this module using FFI.AccessSpecifier
-- but without the FFI.Invalid constructor.
mkEnum ''FFI.AccessSpecifier ['FFI.Invalid]

accessSpecifier :: HasAccessSpecifier t => Cursor t -> AccessSpecifier

Changes

Changelog for enum-subset-generate

Unreleased changes

Depends on 3 packages:
Used by 1 package:
comments powered byDisqus