Hello community, here is the log from the commit of package ghc-MemoTrie for openSUSE:Factory checked in at 2017-04-13 10:44:38 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-MemoTrie (Old) and /work/SRC/openSUSE:Factory/.ghc-MemoTrie.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-MemoTrie" Thu Apr 13 10:44:38 2017 rev:2 rq:461523 version:0.6.7 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-MemoTrie/ghc-MemoTrie.changes 2016-09-24 15:21:56.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-MemoTrie.new/ghc-MemoTrie.changes 2017-04-13 10:44:39.540915161 +0200 @@ -1,0 +2,5 @@ +Sun Feb 12 14:17:37 UTC 2017 - psim...@suse.com + +- Update to version 0.6.7 with cabal2obs. + +------------------------------------------------------------------- Old: ---- 1.cabal MemoTrie-0.6.4.tar.gz New: ---- MemoTrie-0.6.7.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-MemoTrie.spec ++++++ --- /var/tmp/diff_new_pack.JZ5AgN/_old 2017-04-13 10:44:40.012848421 +0200 +++ /var/tmp/diff_new_pack.JZ5AgN/_new 2017-04-13 10:44:40.016847856 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-MemoTrie # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,26 +18,26 @@ %global pkg_name MemoTrie Name: ghc-%{pkg_name} -Version: 0.6.4 +Version: 0.6.7 Release: 0 Summary: Trie-based memo functions License: BSD-3-Clause -Group: System/Libraries +Group: Development/Languages/Other Url: https://hackage.haskell.org/package/%{pkg_name} Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz -Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal BuildRequires: ghc-Cabal-devel +BuildRequires: ghc-newtype-generics-devel BuildRequires: ghc-rpm-macros BuildRoot: %{_tmppath}/%{name}-%{version}-build %description MemoTrie provides a basis for memoized functions over some domains, using tries. It's based on ideas from Ralf Hinze and code from Spencer Janssen. +Generic support thanks to Sam Boosalis. Project wiki page: <http://haskell.org/haskellwiki/MemoTrie> -© 2008-2015 by Conal Elliott; BSD3 license. Generic support thanks to Sam -Boosalis. +© 2008-2016 by Conal Elliott; BSD3 license. %package devel Summary: Haskell %{pkg_name} library development files @@ -52,17 +52,13 @@ %prep %setup -q -n %{pkg_name}-%{version} -cp -p %{SOURCE1} %{pkg_name}.cabal - %build %ghc_lib_build - %install %ghc_lib_install - %post devel %ghc_pkg_recache ++++++ MemoTrie-0.6.4.tar.gz -> MemoTrie-0.6.7.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/MemoTrie-0.6.4/MemoTrie.cabal new/MemoTrie-0.6.7/MemoTrie.cabal --- old/MemoTrie-0.6.4/MemoTrie.cabal 2015-11-21 20:12:36.000000000 +0100 +++ new/MemoTrie-0.6.7/MemoTrie.cabal 2016-09-19 19:03:23.000000000 +0200 @@ -1,17 +1,16 @@ Name: MemoTrie -Version: 0.6.4 +Version: 0.6.7 Cabal-Version: >= 1.10 Synopsis: Trie-based memo functions Category: Data Description: MemoTrie provides a basis for memoized functions over some domains, using tries. It's based on ideas from Ralf Hinze and code from - Spencer Janssen. + Spencer Janssen. Generic support thanks to Sam Boosalis. . Project wiki page: <http://haskell.org/haskellwiki/MemoTrie> . - © 2008-2015 by Conal Elliott; BSD3 license. - Generic support thanks to Sam Boosalis. + © 2008-2016 by Conal Elliott; BSD3 license. Homepage: https://github.com/conal/MemoTrie Author: Conal Elliott Maintainer: co...@conal.net @@ -34,16 +33,14 @@ hs-Source-Dirs: src if impl(ghc >= 7.10.0) - Build-Depends: base >=4.8.0.0 && <5 + Build-Depends: base >=4.8.0.0 && <5, newtype-generics >= 0.4 else - Build-Depends: base <4.8.0.0, void + Build-Depends: base <4.8.0.0, void, newtype-generics >= 0.4 Exposed-Modules: Data.MemoTrie Other-Modules: - ghc-prof-options: -prof -auto-all - default-language: Haskell2010 executable generic diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/MemoTrie-0.6.4/examples/Generic.hs new/MemoTrie-0.6.7/examples/Generic.hs --- old/MemoTrie-0.6.4/examples/Generic.hs 2015-11-21 20:12:36.000000000 +0100 +++ new/MemoTrie-0.6.7/examples/Generic.hs 2016-09-19 19:03:23.000000000 +0200 @@ -2,25 +2,24 @@ import Data.MemoTrie import GHC.Generics (Generic) -data Color - = RGB Int Int Int - | Color String - deriving (Generic) +data Color = RGB Int Int Int + | NamedColor String + deriving (Generic) instance HasTrie Color where - newtype (Color :->: b) = ColorTrie { unColorTrie :: Reg Color :->: b } - trie = trieGeneric ColorTrie - untrie = untrieGeneric unColorTrie - enumerate = enumerateGeneric unColorTrie + newtype (Color :->: b) = ColorTrie { unColorTrie :: Reg Color :->: b } + trie = trieGeneric ColorTrie + untrie = untrieGeneric unColorTrie + enumerate = enumerateGeneric unColorTrie runColor (RGB r g b) = r + g + b -runColor (Color s) = length [1..10e7] +runColor (NamedColor s) = length [1..10e7] runColorMemoized = memo runColor -main = do - putStrLn "first call (should take a few seconds): " - print$ runColorMemoized (Color "") - putStrLn "cached call (should be instantaneous): " - print$ runColorMemoized (Color "") +main = + do putStrLn "first call (should take a few seconds): " + print$ runColorMemoized (NamedColor "") + putStrLn "cached call (should be instantaneous): " + print$ runColorMemoized (NamedColor "") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/MemoTrie-0.6.4/src/Data/MemoTrie.hs new/MemoTrie-0.6.7/src/Data/MemoTrie.hs --- old/MemoTrie-0.6.4/src/Data/MemoTrie.hs 2015-11-21 20:12:36.000000000 +0100 +++ new/MemoTrie-0.6.7/src/Data/MemoTrie.hs 2016-09-19 19:03:23.000000000 +0200 @@ -1,6 +1,6 @@ {-# LANGUAGE GADTs, TypeFamilies, TypeOperators, ScopedTypeVariables, CPP #-} {-# LANGUAGE StandaloneDeriving, FlexibleInstances #-} -{-# LANGUAGE DefaultSignatures, FlexibleContexts, EmptyCase, LambdaCase #-} +{-# LANGUAGE DefaultSignatures, FlexibleContexts, LambdaCase #-} {-# OPTIONS_GHC -Wall -fenable-rewrite-rules #-} -- ScopedTypeVariables works around a 6.10 bug. The forall keyword is @@ -42,7 +42,7 @@ -- see @examples/Generic.hs@, which can be run with: -- -- @ --- $ cabal configure -fexamples && cabal run generic +-- cabal configure -fexamples && cabal run generic -- @ -- -- @@ -55,21 +55,29 @@ , memo, memo2, memo3, mup , inTrie, inTrie2, inTrie3 -- , untrieBits - , trieGeneric, untrieGeneric, enumerateGeneric, Reg + , trieGeneric, untrieGeneric, enumerateGeneric, Reg + , memoFix ) where -- Export the parts of HasTrie separately in order to get the associated data -- type constructors, so I can define instances of other classes on them. +import Data.Function (fix) import Data.Bits import Data.Word import Data.Int +#if !MIN_VERSION_base(4,8,0) import Control.Applicative +#endif import Control.Arrow (first,(&&&)) +#if !MIN_VERSION_base(4,8,0) import Data.Monoid +#endif import Data.Function (on) import GHC.Generics +import Control.Newtype + import Data.Void (Void) -- import Prelude hiding (id,(.)) @@ -128,7 +136,13 @@ -} -{-# RULES "trie/untrie" forall t. trie (untrie t) = t #-} +-- {-# RULES "trie/untrie" forall t. trie (untrie t) = t #-} + +-- warning: [-Winline-rule-shadowing] … +-- Rule "trie/untrie" may never fire +-- because rule "Class op untrie" for ‘untrie’ might fire first +-- Probable fix: add phase [n] or [~n] to the competing rule + -- Don't include the dual rule: -- "untrie/trie" forall f. untrie (trie f) = f @@ -156,6 +170,42 @@ memo2 = mup memo memo3 = mup memo2 +-- | Memoizing recursion. Use like `fix`. +memoFix :: HasTrie a => ((a -> b) -> (a -> b)) -> (a -> b) +memoFix h = fix (memo . h) + +#if 0 +-- Equivalently, + +memoFix h = fix (\ f' -> memo (h f')) + +memoFix h = f' + where f' = memo (h f') + +memoFix h = f' + where + f' = memo f + f = h f' +#endif + +#if 0 +-- Example + +fibF :: (Integer -> Integer) -> (Integer -> Integer) +fibF _ 0 = 1 +fibF _ 1 = 1 +fibF f n = f (n-1) + f (n-2) + +fib :: Integer -> Integer +fib = fix fibF + +fib' :: Integer -> Integer +fib' = memoFix fibF + +-- Try fib 30 vs fib' 30 +#endif + + -- | Apply a unary function inside of a trie inTrie :: (HasTrie a, HasTrie c) => ((a -> b) -> (c -> d)) @@ -179,17 +229,28 @@ instance HasTrie Void where -- As suggested by Audun Skaugen - data Void :->: a = VoidTrie + data Void :->: a = VoidTrie trie _ = VoidTrie - untrie VoidTrie = \case + untrie VoidTrie = \ _ -> error "untrie VoidTrie" + -- \case -- needs EmptyCase enumerate VoidTrie = [] +instance Newtype (Void :->: a) where + type O (Void :->: a) = () + pack () = VoidTrie + unpack VoidTrie = () + instance HasTrie () where newtype () :->: a = UnitTrie a trie f = UnitTrie (f ()) untrie (UnitTrie a) = \ () -> a enumerate (UnitTrie a) = [((),a)] +instance Newtype (() :->: a) where + type O (() :->: a) = a + pack a = UnitTrie a + unpack (UnitTrie a) = a + -- Proofs of inverse properties: {- @@ -225,6 +286,11 @@ untrie (BoolTrie f t) = if' f t enumerate (BoolTrie f t) = [(False,f),(True,t)] +instance Newtype (Bool :->: a) where + type O (Bool :->: a) = (a,a) + pack (a,a') = BoolTrie a a' + unpack (BoolTrie a a') = (a,a') + -- | Conditional with boolean last. -- Spec: @if' (f False) (f True) == f@ if' :: x -> x -> Bool -> x @@ -256,6 +322,11 @@ untrie (EitherTrie s t) = either (untrie s) (untrie t) enumerate (EitherTrie s t) = enum' Left s `weave` enum' Right t +instance Newtype (Either a b :->: x) where + type O (Either a b :->: x) = (a :->: x, b :->: x) + pack (f,g) = EitherTrie f g + unpack (EitherTrie f g) = (f,g) + enum' :: (HasTrie a) => (a -> a') -> (a :->: b) -> [(a', b)] enum' f = (fmap.first) f . enumerate @@ -295,6 +366,11 @@ enumerate (PairTrie tt) = [ ((a,b),x) | (a,t) <- enumerate tt , (b,x) <- enumerate t ] +instance Newtype ((a,b) :->: x) where + type O ((a,b) :->: x) = a :->: b :->: x + pack abx = PairTrie abx + unpack (PairTrie abx) = abx + {- untrie (trie f) == { trie def } @@ -563,7 +639,8 @@ instance HasTrie (V1 x) where data (V1 x :->: b) = V1Trie trie _ = V1Trie - untrie V1Trie = \case + untrie V1Trie = \ _ -> error "untrie V1Trie" + -- \case -- needs EmptyCase enumerate V1Trie = [] -- | just like @()@ @@ -605,6 +682,7 @@ -- "unlifted" generic representation. (i.e. is a unary type constructor). type Reg a = Rep a () +-- | 'Generic'-friendly default for 'trie' trieGeneric :: (Generic a, HasTrie (Reg a)) => ((Reg a :->: b) -> (a :->: b)) -> (a -> b) @@ -612,6 +690,7 @@ trieGeneric theConstructor f = theConstructor (trie (f . to)) {-# INLINEABLE trieGeneric #-} +-- | 'Generic'-friendly default for 'untrie' untrieGeneric :: (Generic a, HasTrie (Reg a)) => ((a :->: b) -> (Reg a :->: b)) -> (a :->: b) @@ -619,6 +698,7 @@ untrieGeneric theDestructor t = \a -> (untrie (theDestructor t)) (from a) {-# INLINEABLE untrieGeneric #-} +-- | 'Generic'-friendly default for 'enumerate' enumerateGeneric :: (Generic a, HasTrie (Reg a)) => ((a :->: b) -> (Reg a :->: b)) -> (a :->: b) @@ -643,4 +723,3 @@ liftSum :: Either (f a) (g a) -> (f :+: g) a liftSum = either L1 R1 {-# INLINEABLE liftSum #-} -