wgaffa/budget - Change H5ZMKSRCKHPZZTZ6ITFKMDWSF25AIJZBEKX6SD77NBHW7ZFX3DSQC

Been playing around with type level stuff

Created by wgaffa on May 16, 2023

H5ZMKSRCKHPZZTZ6ITFKMDWSF25AIJZBEKX6SD77NBHW7ZFX3DSQC

Dependencies

In channels

main

Change contents

File addition: Rule.hs (----------)

[3.162]

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
module Rule (
    -- * Types
    Rule (..),
    -- * Conversion
    fromTuple,
    fromRule,
    defaultRule,
) where
import Data.Proxy
import GHC.TypeLits
-- | The distribution to divide another value by the three different categories.
data Rule t where
    MkRule ::
        forall a b c proxy.
        (KnownNat a, KnownNat b, KnownNat c) =>
        proxy a
        -> proxy b
        -> proxy c
        -> Rule '(a, b, c)
-- | Convert a tuple kind to the term level
fromTuple ::
    forall a b c proxy.
    (KnownNat a, KnownNat b, KnownNat c) =>
    proxy '(a, b, c)
    -> (Integer, Integer, Integer)
fromTuple _ = (natVal (Proxy @a), natVal (Proxy @b), natVal (Proxy @c))
-- | Convert a Distribution type to the term level
fromRule ::
    Rule '(a, b, c)
    -> (Integer, Integer, Integer)
fromRule (MkRule a b c) = (natVal a, natVal b, natVal c)
defaultRule :: Rule '(50, 30, 20)
defaultRule = MkRule (Proxy @50) (Proxy @30) (Proxy @20)

File addition: Money.hs (----------)

[3.162]

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE GADTs #-}
module Money where
import Data.Kind
import Data.Pos
import GHC.TypeLits
-- | Store a positive monetary value
newtype PosMoney (c :: Symbol) = PosMoney {unPosMoney :: Pos}
    deriving (Show)
-- data SomePosMoney = forall c. KnownSymbol c => SomePosMoney (PosMoney c)
data SomePosMoney where
    SomePosMoney :: KnownSymbol c => PosMoney c -> SomePosMoney
-- is ^this equivalent to the below?
data SomePosMoney' :: Type where
    MkSomePosMoney' :: SSymbol s -> PosMoney s -> SomePosMoney'
fromPosMoney :: SSymbol s -> PosMoney s -> SomePosMoney'
fromPosMoney = MkSomePosMoney'
fromPosMoney' :: KnownSymbol s => PosMoney s -> SomePosMoney'
fromPosMoney' = MkSomePosMoney' symbolSing
mkSomePosMoney :: String -> Pos -> SomePosMoney
-- mkSomePosMoney currency amount = withSomeSSymbol currency $ \(ss :: SSymbol s) -> withKnownSymbol ss (mkSomeMoney @s amount)
-- mkSomePosMoney currency amount = withSomeSSymbol currency $ \ss -> mkSomeMoney ss amount
mkSomePosMoney currency amount =
    withSomeSSymbol currency $ \(ss :: SSymbol s) ->
        withKnownSymbol ss (SomePosMoney @s (PosMoney amount))
-- mkSomePosMoney currency amount = withSomeSSymbol currency $ \ss -> withKnownSymbol ss (SomePosMoney (PosMoney amount))
-- mkSomeMoney :: forall (c :: Symbol). Pos -> SomePosMoney
-- mkSomeMoney :: forall c. KnownSymbol c => Pos -> SomePosMoney
-- mkSomeMoney = SomePosMoney @c . PosMoney
-- mkSomeMoney :: forall (c :: Symbol). SSymbol c -> Pos -> SomePosMoney
-- mkSomeMoney ss amount = withKnownSymbol ss $ SomePosMoney @c (PosMoney amount)
getCurrency :: SomePosMoney -> String
getCurrency (SomePosMoney m) = symbolVal m
getCurrency' :: SomePosMoney' -> String
getCurrency' (MkSomePosMoney' s m) = withKnownSymbol s $ symbolVal m
-- getCurrency (SomePosMoney SSymbol) = fromSSymbol $ symbolSing
-- mkMoney :: SomeSymbol -> Int -> Income c
-- mkMoney = undefined

Insertion in lib/Budget.hs at line 1 [3.198]

[3.198]

[3.199]

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}

Insertion in lib/Budget.hs at line 11 [3.198]

[3.244]

[3.275]


    module Money,
    module Rule,
    module Data.Pos,

Insertion in lib/Budget.hs at line 19 [3.198]
[2.52]
[2.52]
```
import Data.Proxy
import Data.Kind
```
Insertion in lib/Budget.hs at line 23 [3.198]
[2.80]
[3.283]
```
import Money
import Rule (Rule)
import Rule as Rule
```

Replacement in lib/Budget.hs at line 28 [3.198]

B:BD[3.284] → [3.284:305]

B:BD[3.305] → [2.81:140]

data Budget = Budget
    { needs :: Pos
    , wants :: Pos
    , savings :: Pos

[3.284]

[3.379]

import GHC.TypeLits
-- | Budget type using a set distribution between the categories Needs, Wants and Savings by
-- | using the 50/30/20 rule.
data Budget (c :: Symbol) (b :: (Nat, Nat, Nat)) = Budget
    { needs :: PosMoney c
    , wants :: PosMoney c
    , savings :: PosMoney c

Replacement in lib/Budget.hs at line 39 [3.198]
B:BD[3.617] → [2.141:159]
```
type Income = Pos
```
[3.617]
[3.674]
```
type Income (c :: Symbol) = PosMoney c
```

Replacement in lib/Budget.hs at line 41 [3.198]

B:BD[3.675] → [3.675:705]

B:BD[3.705] → [2.160:201]

calculate :: Income -> Budget
calculate x = Budget needs wants savings

[3.675]

[2.201]

calculate :: Rule '(n, w, s) -> Income c -> Budget c '(n, w, s)
calculate rule x = Budget needs wants savings

Replacement in lib/Budget.hs at line 44 [3.198]

B:BD[2.209] → [2.209:332]

    income = fromIntegral . unP $ x
    (needs:wants:savings:_) = map (unsafePos "") . distribute [0.5, 0.3, 0.2] $ income

[2.209]

[2.332]

    income = fromIntegral . unP . unPosMoney $ x
    (n, w, s) = Rule.fromRule rule
    basisList = [fromIntegral n, fromIntegral w, fromIntegral s]
    (needs : wants : savings : _) = map (PosMoney . unsafePos "") . distribute basisList $ income

Replacement in budget.cabal at line 24 [3.936]

B:BD[2.915] → [2.915:930]

        Budget

[2.915]

[3.1447]

        Budget,
        Balance,
        Money,
        Rule

Replacement in budget.cabal at line 35 [3.936]
B:BD[2.950] → [2.950:976]
```
        base ^>=4.16.4.0,
```
[2.950]
[2.976]
```
        base ^>=4.18.0.0,
```
Replacement in budget.cabal at line 51 [3.936]
B:BD[3.1951] → [3.1951:1977]
```
        base ^>=4.16.4.0,
```
[3.1951]
[3.1977]
```
        base ^>=4.18.0.0,
```

Replacement in budget.cabal at line 62 [3.936]

B:BD[3.2214] → [3.2214:2253]

    build-depends:    base ^>=4.16.4.0

[3.2214]

    build-depends:    base ^>=4.18.0.0

Insertion in app/Main.hs at line 1 [3.2303]

[3.2303]

[3.2304]

{-# LANGUAGE NumericUnderscores #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE DataKinds #-}

Insertion in app/Main.hs at line 7 [3.2303]
[3.2358]
[3.2358]
```
import Budget
```

Replacement in app/Main.hs at line 11 [3.2303]

B:BD[3.2382] → [3.2382:2411]

  putStrLn "Hello, Haskell!"

[3.2382]

    let inc = PosMoney @"SEK" $ unsafePos "" 15_550
        r = defaultRule
    print $ calculate r inc