Updated to lts-20.18

examples/grenade-examples.cabal

···
                      , bytestring
                      , cereal
                      , either
-                     , optparse-applicative            >= 0.13       && < 0.17
+                     , optparse-applicative            >= 0.13       && < 0.18
                      , text                            == 1.2.*
                      , mtl                             >= 2.2.1      && < 2.3
                      , hmatrix
···
                      , grenade
                      , attoparsec
                      , either
-                     , optparse-applicative            >= 0.13       && < 0.17
+                     , optparse-applicative            >= 0.13       && < 0.18
                      , text                            == 1.2.*
                      , mtl                             >= 2.2.1      && < 2.3
                      , hmatrix                         >= 0.18       && < 0.21
···
                      , bytestring
                      , cereal
                      , either
-                     , optparse-applicative            >= 0.13       && < 0.17
+                     , optparse-applicative            >= 0.13       && < 0.18
                      , text                            == 1.2.*
                      , mtl                             >= 2.2.1      && < 2.3
                      , hmatrix                         >= 0.18       && < 0.21
···
                      , grenade
                      , attoparsec
                      , either
-                     , optparse-applicative            >= 0.13       && < 0.17
+                     , optparse-applicative            >= 0.13       && < 0.18
                      , text                            == 1.2.*
                      , mtl                             >= 2.2.1      && < 2.3
                      , hmatrix                         >= 0.18       && < 0.21
···
                      , bytestring
                      , cereal
                      , either
-                     , optparse-applicative            >= 0.13       && < 0.17
+                     , optparse-applicative            >= 0.13       && < 0.18
                      , text                            == 1.2.*
                      , mtl                             >= 2.2.1      && < 2.3
                      , hmatrix                         >= 0.18       && < 0.21
                      , transformers
                      , semigroups
                      , singletons
+                     , singletons-base
                      , vector
                      , MonadRandom
                      , containers

examples/main/shakespeare.hs

···
 import           Data.List ( foldl' )
 import           Data.Maybe ( fromMaybe )
 
-#if ! MIN_VERSION_base(4,13,0)
-import           Data.Semigroup ( (<>) )
-#endif
 
 import qualified Data.Vector as V
 import           Data.Vector ( Vector )
 
 import qualified Data.Map as M
-#if ! MIN_VERSION_base(4,13,0)
-import           Data.Proxy ( Proxy (..) )
-#endif
 
 import qualified Data.ByteString as B
 import           Data.Serialize
 
-import           Data.Singletons.Prelude
 import           GHC.TypeLits
 
 import           Numeric.LinearAlgebra.Static ( konst )
···
 import           Grenade.Utils.OneHot
 
 import           System.IO.Unsafe ( unsafeInterleaveIO )
+import           Data.Proxy
+import           Prelude.Singletons
 
 -- The defininition for our natural language recurrent network.
 -- This network is able to learn and generate simple words in

grenade.cabal

···
 library
   build-depends:
                        base                            >= 4.8         && < 5
-                     , bytestring                      == 0.10.*
+                     , bytestring                      >= 0.10.0
                      , containers                      >= 0.5         && < 0.7
                      , cereal                          >= 0.5         && < 0.6
                      , deepseq                         >= 1.4         && < 1.5
···
                      -- Versions of singletons are *tightly* coupled with the
                      -- GHC version so its fine to drop version bounds.
                      , singletons
+                     , singletons-base
                      , vector                          >= 0.11        && < 0.13
 
   ghc-options:

src/Grenade/Core/Network.hs

···
 import           Control.Monad.Random ( MonadRandom )
 
 import           Data.Singletons
-import           Data.Singletons.Prelude
 import           Data.Serialize
 
 #if MIN_VERSION_base(4,9,0)
···
 import           Grenade.Core.Layer
 import           Grenade.Core.LearningParameters
 import           Grenade.Core.Shape
+import Prelude.Singletons
 
 -- | Type of a network.
 --

src/Grenade/Core/Runner.hs

···
   , runNet
   ) where
 
-import           Data.Singletons.Prelude
 
 import           Grenade.Core.LearningParameters
 import           Grenade.Core.Network
 import           Grenade.Core.Shape
+import           Data.Singletons
+import           Prelude.Singletons
 
 -- | Perform reverse automatic differentiation on the network
 --   for the current input and expected output.

src/Grenade/Core/Shape.hs

···
 module Grenade.Core.Shape (
     S (..)
   , Shape (..)
-#if MIN_VERSION_singletons(2,6,0)
   , SShape (..)
-#else
-  , Sing (..)
-#endif
-
   , randomOfShape
   , fromStorable
   ) where
 
 import           Control.DeepSeq (NFData (..))
 import           Control.Monad.Random ( MonadRandom, getRandom )
-
-#if MIN_VERSION_base(4,13,0)
 import           Data.Kind (Type)
-#endif
 import           Data.Proxy
 import           Data.Serialize
 import           Data.Singletons
-import           Data.Singletons.TypeLits
 import           Data.Vector.Storable ( Vector )
 import qualified Data.Vector.Storable as V
-
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-
 import qualified Numeric.LinearAlgebra.Static as H
 import           Numeric.LinearAlgebra.Static
 import qualified Numeric.LinearAlgebra as NLA
···
 type instance Sing = SShape
 
 data SShape :: Shape -> Type where
-  D1Sing :: Sing a -> SShape ('D1 a)
-  D2Sing :: Sing a -> Sing b -> SShape ('D2 a b)
-  D3Sing :: KnownNat (a * c) => Sing a -> Sing b -> Sing c -> SShape ('D3 a b c)
+  D1Sing :: KnownNat a => SShape ('D1 a)
+  D2Sing :: (KnownNat a, KnownNat b) => SShape ('D2 a b)
+  D3Sing :: (KnownNat (a * c), KnownNat a, KnownNat b, KnownNat c) => SShape ('D3 a b c)
 #else
 data instance Sing (n :: Shape) where
   D1Sing :: Sing a -> Sing ('D1 a)
···
 #endif
 
 instance KnownNat a => SingI ('D1 a) where
-  sing = D1Sing sing
+  sing = D1Sing
 instance (KnownNat a, KnownNat b) => SingI ('D2 a b) where
-  sing = D2Sing sing sing
+  sing = D2Sing
 instance (KnownNat a, KnownNat b, KnownNat c, KnownNat (a * c)) => SingI ('D3 a b c) where
-  sing = D3Sing sing sing sing
+  sing = D3Sing
 
 instance SingI x => Num (S x) where
   (+) = n2 (+)
···
 randomOfShape = do
   seed :: Int <- getRandom
   return $ case (sing :: Sing x) of
-    D1Sing SNat ->
+    D1Sing ->
         S1D (randomVector  seed Uniform * 2 - 1)
 
-    D2Sing SNat SNat ->
+    D2Sing ->
         S2D (uniformSample seed (-1) 1)
 
-    D3Sing SNat SNat SNat ->
+    D3Sing ->
         S3D (uniformSample seed (-1) 1)
 
 -- | Generate a shape from a Storable Vector.
···
 --   Returns Nothing if the vector is of the wrong size.
 fromStorable :: forall x. SingI x => Vector Double -> Maybe (S x)
 fromStorable xs = case sing :: Sing x of
-    D1Sing SNat ->
+    D1Sing ->
       S1D <$> H.create xs
 
-    D2Sing SNat SNat ->
+    D2Sing ->
       S2D <$> mkL xs
 
-    D3Sing SNat SNat SNat ->
+    D3Sing ->
       S3D <$> mkL xs
   where
     mkL :: forall rows columns. (KnownNat rows, KnownNat columns)
···
 n2 f (S3D x) (S3D y) = S3D (f x y)
 
 -- Helper function for creating the number instances
-nk :: forall x. SingI x => Double -> S x
+nk :: forall x. (SingI x) => Double -> S x
 nk x = case (sing :: Sing x) of
-  D1Sing SNat ->
+  D1Sing ->
     S1D (konst x)
 
-  D2Sing SNat SNat ->
+  D2Sing ->
     S2D (konst x)
 
-  D3Sing SNat SNat SNat ->
+  D3Sing ->
     S3D (konst x)

src/Grenade/Layers/Convolution.hs

···
 import           Data.Maybe
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Numeric.LinearAlgebra hiding ( uniformSample, konst )
 import qualified Numeric.LinearAlgebra as LA

src/Grenade/Layers/Crop.hs

···
 import           Data.Maybe
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Grenade.Core
 import           Grenade.Layers.Internal.Pad

src/Grenade/Layers/Deconvolution.hs

···
 import           Data.Maybe
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Numeric.LinearAlgebra hiding ( uniformSample, konst )
 import qualified Numeric.LinearAlgebra as LA

src/Grenade/Layers/FullyConnected.hs

···
 
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
 import qualified Numeric.LinearAlgebra as LA
 import           Numeric.LinearAlgebra.Static
···
 import           Grenade.Core
 
 import           Grenade.Layers.Internal.Update
+import           GHC.TypeLits
 
 -- | A basic fully connected (or inner product) neural network layer.
 data FullyConnected i o = FullyConnected

src/Grenade/Layers/Pad.hs

···
 import           Data.Maybe
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Grenade.Core
 import           Grenade.Layers.Internal.Pad

src/Grenade/Layers/Pooling.hs

···
 import           Data.Maybe
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,11,0)
-import           GHC.TypeLits hiding (natVal)
-#else
 import           GHC.TypeLits
-#endif
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Grenade.Core
 import           Grenade.Layers.Internal.Pooling

src/Grenade/Layers/Reshape.hs

···
 
 import           Data.Serialize
 
-import           Data.Singletons.TypeLits
 import           GHC.TypeLits
 
 import           Numeric.LinearAlgebra.Static

src/Grenade/Recurrent/Core/Network.hs

···
 
 
 import           Control.Monad.Random ( MonadRandom )
-import           Data.Singletons ( SingI )
-import           Data.Singletons.Prelude ( Head, Last )
 import           Data.Serialize
 
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Grenade.Core
 import           Grenade.Recurrent.Core.Layer
+import           Prelude.Singletons
 
 -- | Witness type to say indicate we're building up with a normal feed
 --   forward layer.

src/Grenade/Recurrent/Core/Runner.hs

···
   ) where
 
 import           Data.List ( foldl' )
-import           Data.Singletons.Prelude
 import           Grenade.Core
 
 import           Grenade.Recurrent.Core.Network
+import           Prelude.Singletons
 
 type RecurrentGradients layers = [RecurrentGradient layers]
 

src/Grenade/Recurrent/Layers/BasicRecurrent.hs

···
 
 import           Control.Monad.Random ( MonadRandom, getRandom )
 
-import           Data.Singletons.TypeLits
 
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import           Numeric.LinearAlgebra.Static
 

src/Grenade/Recurrent/Layers/LSTM.hs

···
 -- import           Data.List ( foldl1' )
 import           Data.Proxy
 import           Data.Serialize
-import           Data.Singletons.TypeLits
-
-#if MIN_VERSION_base(4,9,0)
 import           Data.Kind (Type)
-#endif
 
 import qualified Numeric.LinearAlgebra as LA
 import           Numeric.LinearAlgebra.Static
···
 import           Grenade.Core
 import           Grenade.Recurrent.Core
 import           Grenade.Layers.Internal.Update
+import           GHC.TypeLits
 
 
 -- | Long Short Term Memory Recurrent unit

src/Grenade/Utils/OneHot.hs

···
 import qualified Data.Map as M
 
 import           Data.Proxy
-import           Data.Singletons.TypeLits
 
 import           Data.Vector ( Vector )
 import qualified Data.Vector as V
···
 import           Numeric.LinearAlgebra ( maxIndex )
 import           Numeric.LinearAlgebra.Devel
 import           Numeric.LinearAlgebra.Static
+import           GHC.TypeLits
 
 import           Grenade.Core.Shape
 

stack.yaml

···
 #
 # resolver: ./custom-snapshot.yaml
 # resolver: https://example.com/snapshots/2018-01-01.yaml
-resolver: lts-18.28
+resolver: lts-20.18
 
 # User packages to be built.
 # Various formats can be used as shown in the example below.
···
 #
 # Allow a newer minor version of GHC than the snapshot specifies
 # compiler-check: newer-minor
+
+nix:
+  enable: true
+  packages:
+    - blas
+    - lapack

stack.yaml.lock

···
 - completed:
     hackage: typelits-witnesses-0.3.0.3@sha256:2d9df4ac6ff3077bfd2bf659e4b495e157723ac5b45c519762853f55df5c16db,2738
     pantry-tree:
-      size: 469
       sha256: 6a42a462f98e94933b6e9721acd912c6c6b6a4743635efd15cc5871908c816a0
+      size: 469
   original:
     hackage: typelits-witnesses-0.3.0.3
 snapshots:
 - completed:
-    size: 590100
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/28.yaml
-    sha256: 428ec8d5ce932190d3cbe266b9eb3c175cd81e984babf876b64019e2cbe4ea68
-  original: lts-18.28
+    sha256: 9fa4bece7acfac1fc7930c5d6e24606004b09e80aa0e52e9f68b148201008db9
+    size: 649606
+    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/20/18.yaml
+  original: lts-20.18