type-spec: Type Level Specification by Example

[ bsd3, library, testing ] [ Propose Tags ]

Please see README.md


[Skip to Readme]
Versions [faq] 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.0.1, 0.4.0.0
Dependencies base (>=4.9 && <5), pretty (>=1.1.3 && <1.2) [details]
License BSD-3-Clause
Copyright 2016 Sven Heyll
Author Sven Heyll
Maintainer sven.heyll@gmail.com
Category Testing
Home page https://github.com/sheyll/type-spec#readme
Source repo head: git clone https://github.com/sheyll/type-spec
Uploaded by SvenHeyll at Fri Sep 16 23:53:18 UTC 2016
Distributions LTSHaskell:0.3.0.1, NixOS:0.4.0.0, Stackage:0.4.0.0
Downloads 1613 total (39 in the last 30 days)
Rating 2.0 (votes: 1) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs available [build log]
Last success reported on 2016-09-16 [all 1 reports]

Modules

[Index]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for type-spec-0.3.0.0

[back to package description]

Build Status

Hackage

A tiny EDSL to write type-level-unit tests.

A small example:

import Test.TypeSpec

main :: IO ()
main = print spec0

spec :: Expect (Int `Isn't` Bool)
spec = Valid

This will output:

Valid:
     • Type:  Int
       differs from:  Bool

Using the operators from TypeSpecCrazy:

specCrazy ::

    "Higher kinded assertions"
   ###########################

   "ShouldBe accepts types of kind * -> *"
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       ShouldBe  Maybe Maybe
    -* ShouldBe  []    []
    -* ShouldBe  (->)  (->)

specCrazy = Valid
main = print specCrazy

The output:

Valid:
     Higher kinded assertions
       ShouldBe accepts types of kind * -> *
         • Types are equal
         • Types are equal
         • Types are equal

If you like Lisp, this might be for you:

type ALot = 1000

specAliases ::
  (Explain "There are a variety aliases for the basic combinators."
    (Context "Basic Combinators"
      (Describe "Context"
        (It "labels expectations using 'It'"
          (Describe "Describe"
            (It's "an alias for It, just like They"
              (It's "time for the first assertion"
                (1000 `Is` ALot))))))))
specAliases = Valid

main = print specAliases

This will output:

Valid:
     There are a variety aliases for the basic combinators.
       Basic Combinators
         Context
           Labels expectations using 'It'
             Describe
               is an alias for It, just like They
                 is time for the first assertion
                   • Types are equal

The key feature is that the compiler checks the assertions and expectations made in a 'TypeSpec' and right away rejects invalid types.

When compiling this example:

specFailing ::
    TypeSpec
        (It "counts the number of elements in a tuple"
            (Count ((),(),()) `ShouldBe` 4))
specFailing = Valid

type family Count a :: Nat where
  Count (a,b) = 2
  Count (a,b,c) = 3
  Count (a,b,c,d) = 4

The compiler complains:

error:
   • counts the number of elements in a tuple
         Expected type: 3
         Actual type:   4
   • In the expression: Valid
     In an equation for ‘specFailing’: specFailing = Valid

After all, with TypeError GHC is quite a test-runner.

If you accept to defer type checking and have invalid specs checked during test execution, use (should-not-typecheck)[https://github.com/CRogers/should-not-typecheck].