monoidmap-0.0.0.0: src/test/Data/MonoidMap/ExampleSpec.hs
{-# LANGUAGE OverloadedLists #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{- HLINT ignore "Redundant bracket" -}
{- HLINT ignore "Use camelCase" -}
{- HLINT ignore "Use null" -}
-- |
-- Copyright: © 2022–2023 Jonathan Knowles
-- License: Apache-2.0
--
module Data.MonoidMap.ExampleSpec
where
import Prelude hiding
( gcd, lcm )
import Data.Function
( (&) )
import Data.Group
( Group (..) )
import Data.Monoid
( Product (..), Sum (..) )
import Data.Monoid.GCD
( GCDMonoid (..), LeftGCDMonoid (..), RightGCDMonoid (..) )
import Data.Monoid.LCM
( LCMMonoid (..) )
import Data.Monoid.Monus
( OverlappingGCDMonoid (..), (<\>) )
import Data.MonoidMap
( MonoidMap )
import Data.Ratio
( (%) )
import Data.Semigroup.Cancellative
( LeftReductive (..), RightReductive (..) )
import Data.Set
( Set )
import Numeric.Natural
( Natural )
import Test.Hspec
( Spec, describe )
import Test.Hspec.Unit
( UnitTestData1
, UnitTestData2
, unitTestData1
, unitTestData2
, unitTestSpec
)
import Test.QuickCheck.Instances.Natural
()
import Test.QuickCheck.Instances.Text
()
import qualified Data.MonoidMap as MonoidMap
import qualified Data.Set as Set
spec :: Spec
spec = describe "Examples" $ do
describe "Conversion" $ do
exampleSpec_fromList_String
exampleSpec_toList_String
describe "Comparison" $ do
exampleSpec_isSubmapOf_Sum_Natural
exampleSpec_disjoint_Product_Natural
exampleSpec_disjoint_Sum_Natural
exampleSpec_disjoint_Set_Natural
describe "Intersection" $ do
exampleSpec_intersectionWith_min_Sum_Natural
describe "Union" $ do
exampleSpec_unionWith_max_Sum_Natural
describe "Semigroup" $ do
exampleSpec_Semigroup_mappend_String
exampleSpec_Semigroup_mappend_Sum_Natural
describe "Group" $ do
exampleSpec_Group_invert_Product_Rational
exampleSpec_Group_invert_Sum_Integer
exampleSpec_Group_pow_Product_Rational
exampleSpec_Group_pow_Sum_Integer
exampleSpec_Group_subtract_Product_Rational
exampleSpec_Group_subtract_Sum_Integer
describe "Reductive" $ do
exampleSpec_Reductive_isPrefixOf_String
exampleSpec_Reductive_isPrefixOf_Sum_Natural
exampleSpec_Reductive_isSuffixOf_String
exampleSpec_Reductive_isSuffixOf_Sum_Natural
exampleSpec_Reductive_stripPrefix_String
exampleSpec_Reductive_stripPrefix_Sum_Natural
exampleSpec_Reductive_stripSuffix_String
exampleSpec_Reductive_stripSuffix_Sum_Natural
describe "LeftGCDMonoid" $ do
exampleSpec_LeftGCDMonoid_commonPrefix_String
exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural
exampleSpec_LeftGCDMonoid_stripCommonPrefix_String
exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural
describe "RightGCDMonoid" $ do
exampleSpec_RightGCDMonoid_commonSuffix_String
exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural
exampleSpec_RightGCDMonoid_stripCommonSuffix_String
exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural
describe "OverlappingGCDMonoid" $ do
exampleSpec_OverlappingGCDMonoid_overlap_String
exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural
describe "GCDMonoid" $ do
exampleSpec_GCDMonoid_gcd_Product_Natural
exampleSpec_GCDMonoid_gcd_Sum_Natural
exampleSpec_GCDMonoid_gcd_Set_Natural
describe "LCMMonoid" $ do
exampleSpec_LCMMonoid_lcm_Product_Natural
exampleSpec_LCMMonoid_lcm_Sum_Natural
exampleSpec_LCMMonoid_lcm_Set_Natural
describe "Monus" $ do
exampleSpec_Monus_monus_Set_Natural
exampleSpec_Monus_monus_Sum_Natural
--------------------------------------------------------------------------------
-- Conversion
--------------------------------------------------------------------------------
exampleSpec_fromList_String :: Spec
exampleSpec_fromList_String = unitTestSpec
"MonoidMap.fromList (String)"
"MonoidMap.fromList"
(MonoidMap.fromList)
(exampleData_fromList_String)
exampleData_fromList_String :: UnitTestData1
[(Int, String)]
(MonoidMap Int String)
exampleData_fromList_String = unitTestData1
[ ( [(1, "a"), (2, "x"), (1, "b"), (2, "y"), (1, "c"), (2, "z")]
, [(1, "abc"), (2, "xyz")]
)
]
exampleSpec_toList_String :: Spec
exampleSpec_toList_String = unitTestSpec
"MonoidMap.toList (String)"
"MonoidMap.toList"
(MonoidMap.toList)
(exampleData_toList_String)
exampleData_toList_String :: UnitTestData1
(MonoidMap Int String)
[(Int, String)]
exampleData_toList_String = unitTestData1
[ ( [(3, "z"), (2, "y"), (1, "x")]
, [(1, "x"), (2, "y"), (3, "z")]
)
]
--------------------------------------------------------------------------------
-- Comparison
--------------------------------------------------------------------------------
exampleSpec_isSubmapOf_Sum_Natural :: Spec
exampleSpec_isSubmapOf_Sum_Natural = unitTestSpec
"MonoidMap.isSubmapOf (Sum Natural)"
"MonoidMap.isSubmapOf"
(MonoidMap.isSubmapOf)
(exampleData_isSubmapOf_Sum_Natural)
exampleData_isSubmapOf_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(Bool)
exampleData_isSubmapOf_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3]
, m [4, 4, 4, 4]
, True
)
, ( m [0, 1, 2, 3]
, m [0, 4, 4, 4]
, True
)
, ( m [0, 1, 2, 3]
, m [0, 1, 4, 4]
, True
)
, ( m [0, 1, 2, 3]
, m [0, 1, 2, 4]
, True
)
, ( m [0, 1, 2, 3]
, m [0, 1, 2, 3]
, True
)
, ( m [0, 1, 2, 3]
, m [0, 0, 2, 3]
, False
)
, ( m [0, 1, 2, 3]
, m [0, 1, 1, 3]
, False
)
, ( m [0, 1, 2, 3]
, m [0, 1, 2, 2]
, False
)
, ( m [0, 1, 2, 3]
, m [0, 0, 0, 0]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_disjoint_Product_Natural :: Spec
exampleSpec_disjoint_Product_Natural = unitTestSpec
"MonoidMap.disjoint (Product Natural)"
"MonoidMap.disjoint"
(MonoidMap.disjoint)
(exampleData_disjoint_Product_Natural)
exampleData_disjoint_Product_Natural :: UnitTestData2
(MonoidMap LatinChar (Product Natural))
(MonoidMap LatinChar (Product Natural))
(Bool)
exampleData_disjoint_Product_Natural = unitTestData2
[ ( m []
, m []
, True
)
, ( m [2, 3, 5, 7]
, m [3, 5, 7, 2]
, True
)
, ( m [2 * 3, 5 * 7]
, m [5 * 7, 2 * 3]
, True
)
, ( m [2 * 3 , 3 * 5 ]
, m [ 3 * 5, 5 * 7]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_disjoint_Sum_Natural :: Spec
exampleSpec_disjoint_Sum_Natural = unitTestSpec
"MonoidMap.disjoint (Sum Natural)"
"MonoidMap.disjoint"
(MonoidMap.disjoint)
(exampleData_disjoint_Sum_Natural)
exampleData_disjoint_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(Bool)
exampleData_disjoint_Sum_Natural = unitTestData2
[ ( m []
, m []
, True
)
, ( m [0, 1, 0, 1]
, m [1, 0, 1, 0]
, True
)
, ( m [0, 8, 0, 8]
, m [8, 0, 8, 0]
, True
)
, ( m [0, 8, 0, 8]
, m [8, 0, 8, 1]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_disjoint_Set_Natural :: Spec
exampleSpec_disjoint_Set_Natural = unitTestSpec
"MonoidMap.disjoint (Set Natural)"
"MonoidMap.disjoint"
(MonoidMap.disjoint)
(exampleData_disjoint_Set_Natural)
exampleData_disjoint_Set_Natural :: UnitTestData2
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
(Bool)
exampleData_disjoint_Set_Natural = unitTestData2
[ ( m []
, m []
, True
)
, ( m [[1], [2], [3], [4]]
, m [[5], [6], [7], [8]]
, True
)
, ( m [[1, 2], [3, 4]]
, m [[5, 6], [7, 8]]
, True
)
, ( m [[1, 2 ], [3, 4 ]]
, m [[ 2, 3], [ 4, 5]]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList
--------------------------------------------------------------------------------
-- Intersection
--------------------------------------------------------------------------------
exampleSpec_intersectionWith_min_Sum_Natural :: Spec
exampleSpec_intersectionWith_min_Sum_Natural = unitTestSpec
"MonoidMap.intersectionWith (Sum Natural)"
"MonoidMap.intersectionWith"
(MonoidMap.intersectionWith min)
(exampleData_intersectionWith_min_Sum_Natural)
exampleData_intersectionWith_min_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_intersectionWith_min_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7]
, m [7, 6, 5, 4, 3, 2, 1, 0]
, m [0, 1, 2, 3, 3, 2, 1, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- Union
--------------------------------------------------------------------------------
exampleSpec_unionWith_max_Sum_Natural :: Spec
exampleSpec_unionWith_max_Sum_Natural = unitTestSpec
"MonoidMap.unionWith (Sum Natural)"
"MonoidMap.unionWith"
(MonoidMap.unionWith max)
(exampleData_unionWith_max_Sum_Natural)
exampleData_unionWith_max_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_unionWith_max_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7]
, m [7, 6, 5, 4, 3, 2, 1, 0]
, m [7, 6, 5, 4, 4, 5, 6, 7]
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- Semigroup
--------------------------------------------------------------------------------
exampleSpec_Semigroup_mappend_String :: Spec
exampleSpec_Semigroup_mappend_String = unitTestSpec
"Semigroup.mappend (String)"
"mappend"
(mappend)
(exampleData_Semigroup_concat_String)
exampleData_Semigroup_concat_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_Semigroup_concat_String = unitTestData2
[ ( m ["abc", "ij" , "p" , "" ]
, m [ "", "k", "qr", "xyz"]
, m ["abc", "ijk", "pqr", "xyz"]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Semigroup_mappend_Sum_Natural :: Spec
exampleSpec_Semigroup_mappend_Sum_Natural = unitTestSpec
"Semigroup.mappend (Sum Natural)"
"mappend"
(mappend)
(exampleData_Semigroup_concat_Sum_Natural)
exampleData_Semigroup_concat_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_Semigroup_concat_Sum_Natural = unitTestData2
[ ( m [4, 2, 1, 0]
, m [0, 1, 2, 4]
, m [4, 3, 3, 4]
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- Group
--------------------------------------------------------------------------------
exampleSpec_Group_invert_Product_Rational :: Spec
exampleSpec_Group_invert_Product_Rational = unitTestSpec
"Group.invert (Product Rational)"
"invert"
(invert)
(exampleData_Group_invert_Product_Rational)
exampleData_Group_invert_Product_Rational :: UnitTestData1
(MonoidMap LatinChar (Product Rational))
(MonoidMap LatinChar (Product Rational))
exampleData_Group_invert_Product_Rational = unitTestData1
[ ( m [ 2, 4, 8, 16]
, m [1%2, 1%4, 1%8, 1%16]
)
, ( m [1%2, 1%4, 1%8, 1%16]
, m [ 2, 4, 8, 16]
)
, ( m [ 2, 1%4, 8, 16]
, m [1%2, 4, 1%8, 1%16]
)
, ( m [1%2, 4, 1%8, 1%16]
, m [ 2, 1%4, 8, 16]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Product
exampleSpec_Group_invert_Sum_Integer :: Spec
exampleSpec_Group_invert_Sum_Integer = unitTestSpec
"Group.invert (Sum Integer)"
"invert"
(invert)
(exampleData_Group_invert_Sum_Integer)
exampleData_Group_invert_Sum_Integer :: UnitTestData1
(MonoidMap LatinChar (Sum Integer))
(MonoidMap LatinChar (Sum Integer))
exampleData_Group_invert_Sum_Integer = unitTestData1
[ ( m [ 1, 2, 3, 4]
, m [-1, -2, -3, -4]
)
, ( m [-1, -2, -3, -4]
, m [ 1, 2, 3, 4]
)
, ( m [ 1, -2, 3, -4]
, m [-1, 2, -3, 4]
)
, ( m [-1, 2, -3, 4]
, m [ 1, -2, 3, -4]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Sum
exampleSpec_Group_pow_Product_Rational :: Spec
exampleSpec_Group_pow_Product_Rational = unitTestSpec
"Group.pow (Product Rational)"
"pow"
(pow)
(exampleData_Group_pow_Product_Rational)
exampleData_Group_pow_Product_Rational :: UnitTestData2
(MonoidMap LatinChar (Product Rational))
(Integer)
(MonoidMap LatinChar (Product Rational))
exampleData_Group_pow_Product_Rational = unitTestData2
[ ( m [ 2, -4, 8, -16], (-1)
, m [1%2, -1%4, 1%8, -1%16]
)
, ( m [ 2, -4, 8, -16], 0
, m [ 1, 1, 1, 1]
)
, ( m [ 2, -4, 8, -16], 1
, m [ 2, -4, 8, -16]
)
, ( m [ 2, -4, 8, -16], 2
, m [ 4, 16, 64, 256]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Product
exampleSpec_Group_pow_Sum_Integer :: Spec
exampleSpec_Group_pow_Sum_Integer = unitTestSpec
"Group.pow (Sum Integer)"
"pow"
(pow)
(exampleData_Group_pow_Sum_Integer)
exampleData_Group_pow_Sum_Integer :: UnitTestData2
(MonoidMap LatinChar (Sum Integer))
(Integer)
(MonoidMap LatinChar (Sum Integer))
exampleData_Group_pow_Sum_Integer = unitTestData2
[ ( m [ 1, -2, 3, -4], (-1)
, m [-1, 2, -3, 4]
)
, ( m [ 1, -2, 3, -4], 0
, m [ 0, 0, 0, 0]
)
, ( m [ 1, -2, 3, -4], 1
, m [ 1, -2, 3, -4]
)
, ( m [ 1, -2, 3, -4], 2
, m [ 2, -4, 6, -8]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Sum
exampleSpec_Group_subtract_Product_Rational :: Spec
exampleSpec_Group_subtract_Product_Rational = unitTestSpec
"Group.(~~) (Product Rational)"
"(~~)"
(~~)
(exampleData_Group_subtract_Product_Rational)
exampleData_Group_subtract_Product_Rational :: UnitTestData2
(MonoidMap LatinChar (Product Rational))
(MonoidMap LatinChar (Product Rational))
(MonoidMap LatinChar (Product Rational))
exampleData_Group_subtract_Product_Rational = unitTestData2
[ ( m [ 1, 1, 1, 1]
, m [ 1, 2, 4, 8]
, m [ 1, 1%2, 1%4, 1%8]
)
, ( m [-1, -1, -1, -1]
, m [ 1, 2, 4, 8]
, m [-1, -1%2, -1%4, -1%8]
)
, ( m [ 1, 1, 1, 1]
, m [-1, -2, -4, -8]
, m [-1, -1%2, -1%4, -1%8]
)
, ( m [-1, -1, -1, -1]
, m [-1, -2, -4, -8]
, m [ 1, 1%2, 1%4, 1%8]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Product
exampleSpec_Group_subtract_Sum_Integer :: Spec
exampleSpec_Group_subtract_Sum_Integer = unitTestSpec
"Group.(~~) (Sum Integer)"
"(~~)"
(~~)
(exampleData_Group_subtract_Sum_Integer)
exampleData_Group_subtract_Sum_Integer :: UnitTestData2
(MonoidMap LatinChar (Sum Integer))
(MonoidMap LatinChar (Sum Integer))
(MonoidMap LatinChar (Sum Integer))
exampleData_Group_subtract_Sum_Integer = unitTestData2
[ ( m [ 1, 2, 3, 4]
, m [ 1, 2, 3, 4]
, m [ 0, 0, 0, 0]
)
, ( m [ 0, 0, 0, 0]
, m [ 1, 2, 3, 4]
, m [-1, -2, -3, -4]
)
, ( m [ 1, 2, 3, 4]
, m [-1, -2, -3, -4]
, m [ 2, 4, 6, 8]
)
, ( m [-1, -2, -3, -4]
, m [-1, -2, -3, -4]
, m [ 0, 0, 0, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Sum
--------------------------------------------------------------------------------
-- Reductive
--------------------------------------------------------------------------------
exampleSpec_Reductive_isPrefixOf_String :: Spec
exampleSpec_Reductive_isPrefixOf_String = unitTestSpec
"Reductive.isPrefixOf (String)"
"isPrefixOf"
(isPrefixOf)
(exampleData_Reductive_isPrefixOf_String)
exampleData_Reductive_isPrefixOf_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(Bool)
exampleData_Reductive_isPrefixOf_String = unitTestData2
[ ( m ["A" , "B" , "C" ]
, m ["A123", "B123", "C123"]
, True
)
, ( m ["A123", "B123", "C123"]
, m ["A" , "B" , "C" ]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Reductive_isSuffixOf_String :: Spec
exampleSpec_Reductive_isSuffixOf_String = unitTestSpec
"Reductive.isSuffixOf (String)"
"isSuffixOf"
(isSuffixOf)
(exampleData_Reductive_isSuffixOf_String)
exampleData_Reductive_isSuffixOf_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(Bool)
exampleData_Reductive_isSuffixOf_String = unitTestData2
[ ( m [ "A", "B", "C"]
, m ["123A", "123B", "123C"]
, True
)
, ( m ["123A", "123B", "123C"]
, m [ "A", "B", "C"]
, False
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Reductive_isPrefixOf_Sum_Natural :: Spec
exampleSpec_Reductive_isPrefixOf_Sum_Natural = unitTestSpec
"Reductive.isPrefixOf (Sum Natural)"
"isPrefixOf"
(isPrefixOf)
(exampleData_Reductive_Sum_Natural)
exampleSpec_Reductive_isSuffixOf_Sum_Natural :: Spec
exampleSpec_Reductive_isSuffixOf_Sum_Natural = unitTestSpec
"Reductive.isSuffixOf (Sum Natural)"
"isSuffixOf"
(isSuffixOf)
(exampleData_Reductive_Sum_Natural)
exampleData_Reductive_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(Bool)
exampleData_Reductive_Sum_Natural = unitTestData2
[ ( m [1, 1], m [1, 1], True )
, ( m [1, 1], m [1, 2], True )
, ( m [1, 1], m [2, 1], True )
, ( m [1, 1], m [2, 2], True )
, ( m [1, 2], m [1, 1], False)
, ( m [1, 2], m [1, 2], True )
, ( m [1, 2], m [2, 1], False)
, ( m [1, 2], m [2, 2], True )
, ( m [2, 1], m [1, 1], False)
, ( m [2, 1], m [1, 2], False)
, ( m [2, 1], m [2, 1], True )
, ( m [2, 1], m [2, 2], True )
, ( m [2, 2], m [1, 1], False)
, ( m [2, 2], m [1, 2], False)
, ( m [2, 2], m [2, 1], False)
, ( m [2, 2], m [2, 2], True )
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Sum
exampleSpec_Reductive_stripPrefix_String :: Spec
exampleSpec_Reductive_stripPrefix_String = unitTestSpec
"Reductive.stripPrefix (String)"
"stripPrefix"
(stripPrefix)
(exampleData_Reductive_stripPrefix_String)
exampleData_Reductive_stripPrefix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(Maybe (MonoidMap LatinChar String))
exampleData_Reductive_stripPrefix_String = unitTestData2
[ ( m ["" , "" , "" ]
, m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"] & Just
)
, ( m ["a" , "p" , "x" ]
, m ["abc", "pqr", "xyz"]
, m [ "bc", "qr", "yz"] & Just
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, m [ "", "", ""] & Just
)
, ( m ["?" , "p" , "x" ]
, m ["abc", "pqr", "xyz"]
, Nothing
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Reductive_stripPrefix_Sum_Natural :: Spec
exampleSpec_Reductive_stripPrefix_Sum_Natural = unitTestSpec
"Reductive.stripPrefix (Sum Natural)"
"stripPrefix"
(stripPrefix)
(exampleData_Reductive_stripPrefix_Sum_Natural)
exampleData_Reductive_stripPrefix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(Maybe (MonoidMap LatinChar (Sum Natural)))
exampleData_Reductive_stripPrefix_Sum_Natural = unitTestData2
[ ( m [0, 0, 0]
, m [2, 4, 8]
, m [2, 4, 8] & Just
)
, ( m [1, 2, 4]
, m [2, 4, 8]
, m [1, 2, 4] & Just
)
, ( m [2, 4, 8]
, m [2, 4, 8]
, m [0, 0, 0] & Just
)
, ( m [3, 4, 8]
, m [2, 4, 8]
, Nothing
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Reductive_stripSuffix_String :: Spec
exampleSpec_Reductive_stripSuffix_String = unitTestSpec
"Reductive.stripSuffix (String)"
"stripSuffix"
(stripSuffix)
(exampleData_Reductive_stripSuffix_String)
exampleData_Reductive_stripSuffix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(Maybe (MonoidMap LatinChar String))
exampleData_Reductive_stripSuffix_String = unitTestData2
[ ( m [ "", "", ""]
, m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"] & Just
)
, ( m [ "c", "r", "z"]
, m ["abc", "pqr", "xyz"]
, m ["ab" , "pq" , "xy" ] & Just
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, m ["" , "" , "" ] & Just
)
, ( m [ "?", "r", "z"]
, m ["abc", "pqr", "xyz"]
, Nothing
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_Reductive_stripSuffix_Sum_Natural :: Spec
exampleSpec_Reductive_stripSuffix_Sum_Natural = unitTestSpec
"Reductive.stripSuffix (Sum Natural)"
"stripSuffix"
(stripSuffix)
(exampleData_Reductive_stripSuffix_Sum_Natural)
exampleData_Reductive_stripSuffix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(Maybe (MonoidMap LatinChar (Sum Natural)))
exampleData_Reductive_stripSuffix_Sum_Natural = unitTestData2
[ ( m [0, 0, 0]
, m [2, 4, 8]
, m [2, 4, 8] & Just
)
, ( m [1, 2, 4]
, m [2, 4, 8]
, m [1, 2, 4] & Just
)
, ( m [2, 4, 8]
, m [2, 4, 8]
, m [0, 0, 0] & Just
)
, ( m [3, 4, 8]
, m [2, 4, 8]
, Nothing
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- LeftGCDMonoid
--------------------------------------------------------------------------------
exampleSpec_LeftGCDMonoid_commonPrefix_String :: Spec
exampleSpec_LeftGCDMonoid_commonPrefix_String = unitTestSpec
"LeftGCDMonoid.commonPrefix (String)"
"commonPrefix"
(commonPrefix)
(exampleData_LeftGCDMonoid_commonPrefix_String)
exampleData_LeftGCDMonoid_commonPrefix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_LeftGCDMonoid_commonPrefix_String = unitTestData2
[ ( m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
, m ["" , "" , "" ]
)
, ( m ["a--", "p--", "x--"]
, m ["abc", "pqr", "xyz"]
, m ["a" , "p" , "x" ]
)
, ( m ["ab-", "pq-", "xy-"]
, m ["abc", "pqr", "xyz"]
, m ["ab" , "pq" , "xy" ]
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
)
, ( m ["abc", "pqr", "xyz"]
, m ["ab-", "pq-", "xy-"]
, m ["ab" , "pq" , "xy" ]
)
, ( m ["abc", "pqr", "xyz"]
, m ["a--", "p--", "x--"]
, m ["a" , "p" , "x" ]
)
, ( m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
, m ["" , "" , "" ]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural :: Spec
exampleSpec_LeftGCDMonoid_commonPrefix_Sum_Natural = unitTestSpec
"LeftGCDMonoid.commonPrefix (Sum Natural)"
"commonPrefix"
(commonPrefix)
(exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural)
exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_LeftGCDMonoid_commonPrefix_Sum_Natural = unitTestData2
[ ( m [0, 0, 0]
, m [1, 2, 3]
, m [0, 0, 0]
)
, ( m [1, 1, 1]
, m [1, 2, 3]
, m [1, 1, 1]
)
, ( m [2, 2, 2]
, m [1, 2, 3]
, m [1, 2, 2]
)
, ( m [3, 3, 3]
, m [1, 2, 3]
, m [1, 2, 3]
)
, ( m [4, 4, 4]
, m [1, 2, 3]
, m [1, 2, 3]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_LeftGCDMonoid_stripCommonPrefix_String :: Spec
exampleSpec_LeftGCDMonoid_stripCommonPrefix_String = unitTestSpec
"LeftGCDMonoid.stripCommonPrefix (String)"
"stripCommonPrefix"
(stripCommonPrefix)
(exampleData_LeftGCDMonoid_stripCommonPrefix_String)
exampleData_LeftGCDMonoid_stripCommonPrefix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
( MonoidMap LatinChar String
, MonoidMap LatinChar String
, MonoidMap LatinChar String
)
exampleData_LeftGCDMonoid_stripCommonPrefix_String = unitTestData2
[ ( m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
, ( m ["" , "" , "" ]
, m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
)
)
, ( m ["a--", "p--", "x--"]
, m ["abc", "pqr", "xyz"]
, ( m ["a" , "p" , "x" ]
, m [ "--", "--", "--"]
, m [ "bc", "qr", "yz"]
)
)
, ( m ["ab-", "pq-", "xy-"]
, m ["abc", "pqr", "xyz"]
, ( m ["ab" , "pq" , "xy" ]
, m [ "-", "-", "-"]
, m [ "c", "r", "z"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, ( m ["abc", "pqr", "xyz"]
, m [ "", "", ""]
, m [ "", "", ""]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["ab-", "pq-", "xy-"]
, ( m ["ab" , "pq" , "xy" ]
, m [ "c", "r", "z"]
, m [ "-", "-", "-"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["a--", "p--", "x--"]
, ( m ["a" , "p" , "x" ]
, m [ "bc", "qr", "yz"]
, m [ "--", "--", "--"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
, ( m ["" , "" , "" ]
, m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
)
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural :: Spec
exampleSpec_LeftGCDMonoid_stripCommonPrefix_Sum_Natural = unitTestSpec
"LeftGCDMonoid.stripCommonPrefix (Sum Natural)"
"stripCommonPrefix"
(stripCommonPrefix)
(exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural)
exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
( MonoidMap LatinChar (Sum Natural)
, MonoidMap LatinChar (Sum Natural)
, MonoidMap LatinChar (Sum Natural)
)
exampleData_LeftGCDMonoid_stripCommonPrefix_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4]
, m [4, 3, 2, 1, 0]
, ( m [0, 1, 2, 1, 0]
, m [0, 0, 0, 2, 4]
, m [4, 2, 0, 0, 0]
)
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- RightGCDMonoid
--------------------------------------------------------------------------------
exampleSpec_RightGCDMonoid_commonSuffix_String :: Spec
exampleSpec_RightGCDMonoid_commonSuffix_String = unitTestSpec
"RightGCDMonoid.commonSuffix (String)"
"commonSuffix"
(commonSuffix)
(exampleData_RightGCDMonoid_commonSuffix_String)
exampleData_RightGCDMonoid_commonSuffix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_RightGCDMonoid_commonSuffix_String = unitTestData2
[ ( m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
, m [ "" , "", ""]
)
, ( m ["--c", "--r", "--z"]
, m ["abc", "pqr", "xyz"]
, m [ "c", "r", "z"]
)
, ( m ["-bc", "-qr", "-yz"]
, m ["abc", "pqr", "xyz"]
, m [ "bc", "qr", "yz"]
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
)
, ( m ["abc", "pqr", "xyz"]
, m ["-bc", "-qr", "-yz"]
, m [ "bc", "qr", "yz"]
)
, ( m ["abc", "pqr", "xyz"]
, m ["--c", "--r", "--z"]
, m [ "c", "r", "z"]
)
, ( m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
, m [ "", "", ""]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural :: Spec
exampleSpec_RightGCDMonoid_commonSuffix_Sum_Natural = unitTestSpec
"RightGCDMonoid.commonSuffix (Sum Natural)"
"commonSuffix"
(commonSuffix)
(exampleData_RightGCDMonoid_commonSuffix_Sum_Natural)
exampleData_RightGCDMonoid_commonSuffix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_RightGCDMonoid_commonSuffix_Sum_Natural = unitTestData2
[ ( m [0, 0, 0]
, m [1, 2, 3]
, m [0, 0, 0]
)
, ( m [1, 1, 1]
, m [1, 2, 3]
, m [1, 1, 1]
)
, ( m [2, 2, 2]
, m [1, 2, 3]
, m [1, 2, 2]
)
, ( m [3, 3, 3]
, m [1, 2, 3]
, m [1, 2, 3]
)
, ( m [4, 4, 4]
, m [1, 2, 3]
, m [1, 2, 3]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_RightGCDMonoid_stripCommonSuffix_String :: Spec
exampleSpec_RightGCDMonoid_stripCommonSuffix_String = unitTestSpec
"RightGCDMonoid.stripCommonSuffix (String)"
"stripCommonSuffix"
(stripCommonSuffix)
(exampleData_RightGCDMonoid_stripCommonSuffix_String)
exampleData_RightGCDMonoid_stripCommonSuffix_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
( MonoidMap LatinChar String
, MonoidMap LatinChar String
, MonoidMap LatinChar String
)
exampleData_RightGCDMonoid_stripCommonSuffix_String = unitTestData2
[ ( m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
, ( m ["---", "---", "---"]
, m ["abc", "pqr", "xyz"]
, m [ "", "", ""]
)
)
, ( m ["--c", "--r", "--z"]
, m ["abc", "pqr", "xyz"]
, ( m ["--" , "--" , "--" ]
, m ["ab" , "pq" , "xy" ]
, m [ "c", "r", "z"]
)
)
, ( m ["--c", "--r", "--z"]
, m ["abc", "pqr", "xyz"]
, ( m ["--" , "--" , "--" ]
, m ["ab" , "pq" , "xy" ]
, m [ "c", "r", "z"]
)
)
, ( m ["-bc", "-qr", "-yz"]
, m ["abc", "pqr", "xyz"]
, ( m ["-" , "-" , "-" ]
, m ["a" , "p" , "x" ]
, m [ "bc", "qr", "yz"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["abc", "pqr", "xyz"]
, ( m ["" , "" , "" ]
, m ["" , "" , "" ]
, m ["abc", "pqr", "xyz"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["-bc", "-qr", "-yz"]
, ( m ["a" , "p" , "x" ]
, m ["-" , "-" , "-" ]
, m [ "bc", "qr", "yz"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["--c", "--r", "--z"]
, ( m ["ab" , "pq" , "xy" ]
, m ["--" , "--" , "--" ]
, m [ "c", "r", "z"]
)
)
, ( m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
, ( m ["abc", "pqr", "xyz"]
, m ["---", "---", "---"]
, m [ "", "", ""]
)
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural :: Spec
exampleSpec_RightGCDMonoid_stripCommonSuffix_Sum_Natural = unitTestSpec
"RightGCDMonoid.stripCommonSuffix (Sum Natural)"
"stripCommonSuffix"
(stripCommonSuffix)
(exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural)
exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
( MonoidMap LatinChar (Sum Natural)
, MonoidMap LatinChar (Sum Natural)
, MonoidMap LatinChar (Sum Natural)
)
exampleData_RightGCDMonoid_stripCommonSuffix_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4]
, m [4, 3, 2, 1, 0]
, ( m [0, 0, 0, 2, 4]
, m [4, 2, 0, 0, 0]
, m [0, 1, 2, 1, 0]
)
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- OverlappingGCDMonoid
--------------------------------------------------------------------------------
exampleSpec_OverlappingGCDMonoid_overlap_String :: Spec
exampleSpec_OverlappingGCDMonoid_overlap_String = unitTestSpec
"OverlappingGCDMonoid.overlap (String)"
"overlap"
(overlap)
(exampleData_OverlappingGCDMonoid_overlap_String)
exampleData_OverlappingGCDMonoid_overlap_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_OverlappingGCDMonoid_overlap_String = unitTestData2
[ ( m ["abcd" , "0123" ]
, m [ "efgh", "4567"]
, m [ "" , "" ]
)
, ( m ["abcde" , "01234" ]
, m [ "defgh", "34567"]
, m [ "de" , "34" ]
)
, ( m ["abcdef" , "012345" ]
, m [ "cdefgh", "234567"]
, m [ "cdef" , "2345" ]
)
, ( m ["abcdefg" , "0123456" ]
, m [ "bcdefgh", "1234567"]
, m [ "bcdefg" , "123456" ]
)
, ( m ["abcdefgh", "01234567"]
, m ["abcdefgh", "01234567"]
, m ["abcdefgh", "01234567"]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural :: Spec
exampleSpec_OverlappingGCDMonoid_overlap_Sum_Natural = unitTestSpec
"OverlappingGCDMonoid.overlap (Sum Natural)"
"overlap"
(overlap)
(exampleData_OverlappingGCDMonoid_overlap_Sum_Natural)
exampleData_OverlappingGCDMonoid_overlap_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_OverlappingGCDMonoid_overlap_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String :: Spec
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_String = unitTestSpec
"OverlappingGCDMonoid.stripPrefixOverlap (String)"
"stripPrefixOverlap"
(stripPrefixOverlap)
(exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String)
exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_OverlappingGCDMonoid_stripPrefixOverlap_String = unitTestData2
[ ( m ["abcd" , "0123" ]
, m [ "efgh", "4567"]
, m [ "efgh", "4567"]
)
, ( m ["abcde" , "01234" ]
, m [ "defgh", "34567"]
, m [ "fgh", "567"]
)
, ( m ["abcdef" , "012345" ]
, m [ "cdefgh", "234567"]
, m [ "gh", "67"]
)
, ( m ["abcdefg" , "0123456" ]
, m [ "bcdefgh", "1234567"]
, m [ "h", "7"]
)
, ( m ["abcdefgh", "01234567"]
, m ["abcdefgh", "01234567"]
, m [ "", ""]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String :: Spec
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_String = unitTestSpec
"OverlappingGCDMonoid.stripSuffixOverlap (String)"
"stripSuffixOverlap"
(stripSuffixOverlap)
(exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String)
exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String :: UnitTestData2
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
(MonoidMap LatinChar String)
exampleData_OverlappingGCDMonoid_stripSuffixOverlap_String = unitTestData2
[ ( m [ "efgh", "4567"]
, m ["abcd" , "0123" ]
, m ["abcd" , "0123" ]
)
, ( m [ "defgh", "34567"]
, m ["abcde" , "01234" ]
, m ["abc" , "012" ]
)
, ( m [ "cdefgh", "234567"]
, m ["abcdef" , "012345" ]
, m ["ab" , "01" ]
)
, ( m [ "bcdefgh", "1234567"]
, m ["abcdefg" , "0123456" ]
, m ["a" , "0" ]
)
, ( m ["abcdefgh", "01234567"]
, m ["abcdefgh", "01234567"]
, m ["" , "" ]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural :: Spec
exampleSpec_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural = unitTestSpec
"OverlappingGCDMonoid.stripPrefixOverlap (Sum Natural)"
"stripPrefixOverlap"
(stripPrefixOverlap)
(exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural)
exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural
:: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_OverlappingGCDMonoid_stripPrefixOverlap_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [9, 7, 5, 3, 1, 0, 0, 0, 0, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural :: Spec
exampleSpec_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural = unitTestSpec
"OverlappingGCDMonoid.stripSuffixOverlap (Sum Natural)"
"stripSuffixOverlap"
(stripSuffixOverlap)
(exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural)
exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural
:: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_OverlappingGCDMonoid_stripSuffixOverlap_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [9, 7, 5, 3, 1, 0, 0, 0, 0, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- GCDMonoid
--------------------------------------------------------------------------------
exampleSpec_GCDMonoid_gcd_Product_Natural :: Spec
exampleSpec_GCDMonoid_gcd_Product_Natural = unitTestSpec
"GCDMonoid.gcd (Product Natural)"
"gcd"
(gcd)
(exampleData_GCDMonoid_gcd_Product_Natural)
exampleData_GCDMonoid_gcd_Product_Natural :: UnitTestData2
(MonoidMap LatinChar (Product Natural))
(MonoidMap LatinChar (Product Natural))
(MonoidMap LatinChar (Product Natural))
exampleData_GCDMonoid_gcd_Product_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
, m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
, m [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
, m [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
, m [3, 1, 1, 3, 1, 1, 3, 1, 1, 3]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
, m [4, 1, 2, 1, 4, 1, 2, 1, 4, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
, m [5, 1, 1, 1, 1, 5, 1, 1, 1, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
, m [6, 1, 2, 3, 2, 1, 6, 1, 2, 3]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [7, 7, 7, 7, 7, 7, 7, 7, 7, 7]
, m [7, 1, 1, 1, 1, 1, 1, 7, 1, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
, m [8, 1, 2, 1, 4, 1, 2, 1, 8, 1]
)
, ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
, m [9, 1, 1, 3, 1, 1, 3, 1, 1, 9]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_GCDMonoid_gcd_Sum_Natural :: Spec
exampleSpec_GCDMonoid_gcd_Sum_Natural = unitTestSpec
"GCDMonoid.gcd (Sum Natural)"
"gcd"
(gcd)
(exampleData_GCDMonoid_gcd_Sum_Natural)
exampleData_GCDMonoid_gcd_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_GCDMonoid_gcd_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]
)
, ( m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [0, 1, 2, 3, 4, 4, 3, 2, 1, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_GCDMonoid_gcd_Set_Natural :: Spec
exampleSpec_GCDMonoid_gcd_Set_Natural = unitTestSpec
"GCDMonoid.gcd (Set Natural)"
"gcd"
(gcd)
(exampleData_GCDMonoid_gcd_Set_Natural)
exampleData_GCDMonoid_gcd_Set_Natural :: UnitTestData2
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
exampleData_GCDMonoid_gcd_Set_Natural = unitTestData2
[ ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ ], [ ]]
, m [[ ], [ ]]
)
, ( m [[ ], [ ]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ ], [ ]]
)
, ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
)
, ( m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
)
, ( m [[0, 1, 2 ], [4, 5, 6 ]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[ 1, 2 ], [ 5, 6 ]]
)
, ( m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2 ], [4, 5, 6 ]]
, m [[ 1, 2 ], [ 5, 6 ]]
)
, ( m [[0, 1 ], [4, 5 ]]
, m [[ 2, 3], [ 6, 7]]
, m [[ ], [ ]]
)
, ( m [[ 2, 3], [ 6, 7]]
, m [[0, 1 ], [4, 5 ]]
, m [[ ], [ ]]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList
--------------------------------------------------------------------------------
-- LCMMonoid
--------------------------------------------------------------------------------
exampleSpec_LCMMonoid_lcm_Product_Natural :: Spec
exampleSpec_LCMMonoid_lcm_Product_Natural = unitTestSpec
"LCMMonoid.lcm (Product Natural)"
"lcm"
(lcm)
(exampleData_LCMMonoid_lcm_Product_Natural)
exampleData_LCMMonoid_lcm_Product_Natural :: UnitTestData2
(MonoidMap LatinChar (Product Natural))
(MonoidMap LatinChar (Product Natural))
(MonoidMap LatinChar (Product Natural))
exampleData_LCMMonoid_lcm_Product_Natural = unitTestData2
[ ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
, m [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
, m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
, m [ 0, 2, 2, 6, 4, 10, 6, 14, 8, 18]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
, m [ 0, 3, 6, 3, 12, 15, 6, 21, 24, 9]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
, m [ 0, 4, 4, 12, 4, 20, 12, 28, 8, 36]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
, m [ 0, 5, 10, 15, 20, 5, 30, 35, 40, 45]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
, m [ 0, 6, 6, 6, 12, 30, 6, 42, 24, 18]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]
, m [ 0, 7, 14, 21, 28, 35, 42, 7, 56, 63]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
, m [ 0, 8, 8, 24, 8, 40, 24, 56, 8, 72]
)
, ( m [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [ 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
, m [ 0, 9, 18, 9, 36, 45, 18, 63, 72, 9]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_LCMMonoid_lcm_Sum_Natural :: Spec
exampleSpec_LCMMonoid_lcm_Sum_Natural = unitTestSpec
"LCMMonoid.lcm (Sum Natural)"
"lcm"
(lcm)
(exampleData_LCMMonoid_lcm_Sum_Natural)
exampleData_LCMMonoid_lcm_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_LCMMonoid_lcm_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [9, 8, 7, 6, 5, 5, 6, 7, 8, 9]
)
, ( m [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
, m [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
, m [9, 8, 7, 6, 5, 5, 6, 7, 8, 9]
)
]
where
m = MonoidMap.fromList . zip [A ..]
exampleSpec_LCMMonoid_lcm_Set_Natural :: Spec
exampleSpec_LCMMonoid_lcm_Set_Natural = unitTestSpec
"LCMMonoid.lcm (Set Natural)"
"lcm"
(lcm)
(exampleData_LCMMonoid_lcm_Set_Natural)
exampleData_LCMMonoid_lcm_Set_Natural :: UnitTestData2
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
exampleData_LCMMonoid_lcm_Set_Natural = unitTestData2
[ ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ ], [ ]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[ ], [ ]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[0, 1, 2 ], [4, 5, 6 ]]
, m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[ 1, 2, 3], [ 5, 6, 7]]
, m [[0, 1, 2 ], [4, 5, 6 ]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[0, 1 ], [4, 5 ]]
, m [[ 2, 3], [ 6, 7]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
, ( m [[ 2, 3], [ 6, 7]]
, m [[0, 1 ], [4, 5 ]]
, m [[0, 1, 2, 3], [4, 5, 6, 7]]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList
--------------------------------------------------------------------------------
-- Monus
--------------------------------------------------------------------------------
exampleSpec_Monus_monus_Set_Natural :: Spec
exampleSpec_Monus_monus_Set_Natural = unitTestSpec
"Monus.monus (Set Natural)"
"<\\>"
(<\>)
(exampleData_Monus_monus_Set_Natural)
exampleData_Monus_monus_Set_Natural :: UnitTestData2
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
(MonoidMap LatinChar (Set Natural))
exampleData_Monus_monus_Set_Natural = unitTestData2
[ ( m [[0, 1, 2], [3, 4, 5]]
, m [[ ], [ ]]
, m [[0, 1, 2], [3, 4, 5]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[0 ], [3 ]]
, m [[ 1, 2], [ 4, 5]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[ 1 ], [ 4 ]]
, m [[0, 2], [3, 5]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[ 2], [ 5]]
, m [[0, 1 ], [3, 4 ]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[0, 1, 2], [3, 4, 5]]
, m [[ ], [ ]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[3, 4, 5], [0, 1, 2]]
, m [[0, 1, 2], [3, 4, 5]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[2, 3, 4], [1, 2, 3]]
, m [[0, 1 ], [ 4, 5]]
)
, ( m [[0, 1, 2], [3, 4, 5]]
, m [[1, 2, 3], [2, 3, 4]]
, m [[0 ], [ 5]]
)
]
where
m = MonoidMap.fromList . zip [A ..] . fmap Set.fromList
exampleSpec_Monus_monus_Sum_Natural :: Spec
exampleSpec_Monus_monus_Sum_Natural = unitTestSpec
"Monus.monus (Sum Natural)"
"<\\>"
(<\>)
(exampleData_Monus_monus_Sum_Natural)
exampleData_Monus_monus_Sum_Natural :: UnitTestData2
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
(MonoidMap LatinChar (Sum Natural))
exampleData_Monus_monus_Sum_Natural = unitTestData2
[ ( m [0, 1, 2, 3]
, m [0, 0, 0, 0]
, m [0, 1, 2, 3]
)
, ( m [0, 1, 2, 3]
, m [1, 1, 1, 1]
, m [0, 0, 1, 2]
)
, ( m [0, 1, 2, 3]
, m [2, 2, 2, 2]
, m [0, 0, 0, 1]
)
, ( m [0, 1, 2, 3]
, m [3, 3, 3, 3]
, m [0, 0, 0, 0]
)
, ( m [0, 1, 2, 3]
, m [4, 4, 4, 4]
, m [0, 0, 0, 0]
)
]
where
m = MonoidMap.fromList . zip [A ..]
--------------------------------------------------------------------------------
-- Utilities
--------------------------------------------------------------------------------
data LatinChar
= A | B | C | D | E | F | G | H | I | J | K | L | M
| N | O | P | Q | R | S | T | U | V | W | X | Y | Z
deriving (Bounded, Enum, Eq, Ord, Show)