finite: Finite ranges via types

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

A framework for capturing finite ranges with types, where the sizes of the ranges are not fixed statically at compile time, but instead are passed at run-time via implicit parameters.

This is especially useful for objects of bounded size, e.g. finite automata, where the number of elements being part of the object, e.g. the number of states, is well-defined in the context of the object.


[Skip to Readme]

Properties

Versions 1.4.1.1, 1.4.1.1, 1.4.1.2
Change log None available
Dependencies array (==0.5.*), base (>=4.7 && <4.13), containers (>=0.5 && <0.7), hashable (>=1.2), QuickCheck, template-haskell (>=2.11) [details]
License MIT
Author Felix Klein <klein@react.uni-saarland.de>
Maintainer Felix Klein <klein@react.uni-saarland.de>
Category Types
Source repo head: git clone https://github.com/kleinreact/finite
Uploaded by kleinreact at 2021-01-25T10:16:54Z

Modules

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for finite-1.4.1.1

[back to package description]

Finite

The library provides the Haskell class Finite, which allows to associate types with finite ranges of elements in the context of a bounding environment. The purpose of the class is to simplify the handling of objects of bounded size, e.g. finite-state machines, where the number of elements can be defined in the context of the object, e.g. the number of states.

Main Features

Example: Finite-State Machines

import Finite
import Finite.TH

-- create two new basic types for the states and labels of the FSM
newInstance "State"
newInstance "Label"

-- FSM data type
data FSM =
  FSM
    { states :: Int
    , labels :: Int
    , transition :: State -> Label -> State
    , accepting :: State -> Bool
    , labelName :: Label -> String
    }

-- connect the types with corresponding bounds, as defined by the FSM
baseInstance [t|FSM|] [|states|] "State"
baseInstance [t|FSM|] [|labels|] "Label"

-- FSM Show instance for demonstrating the features of 'Finite'
instance Show FSM where
  show fsm =
    -- set the context
    let ?bounds = fsm in
    -- show the data
    unlines $
      [ "The FSM has " ++ show (elements ((#) :: T State)) ++ " states."
      ] ++
      [ "Labels:"
      ] ++
      [ "  (" ++ show (index l) ++ ") " ++ labelName fsm l
      | l <- values
      ] ++
      [ "Transitions:"
      ] ++
      [ "  " ++ show (index s) ++ " -- " ++ labelName fsm l ++
        " --> " ++ show (index (transition fsm s l))
      | s <- values
      , l <- values
      ] ++
      [ "Accepting:"
      ] ++
      [ "  " ++ show (map index $ filter (accepting fsm) values)
      ]