Elm calculation using fold - elm

Question

I just started playing around with Elm and functional programming. I really like the language but I do have trouble implementing very simply calculations.
My below code takes as input wacc : Float and cfs : List Float and should calculate a net preset value (i.e. for each element of cfs calculate cfs_i / (1 + wacc)^i and then calculate the sum of the values).
The code works but is very verbose and potentially not idiomatic.
My main question besides hints how to make it more concise / idiomatic is how do I change my code to be able to accept wacc and cfs of types Maybe.
Helpful for any hint / info. Thanks!
-- helper functions
zip : List a -> List b -> List (a,b)
zip list1 list2 =
List.map2 Tuple.pair list1 list2
calcDF : Float -> Int -> List Float
calcDF wacc n =
let
waccs = List.repeat n wacc
time = List.range 0 n |> List.map toFloat
waccs_time = zip waccs time
in
List.map (\x -> 1/ (1 + Tuple.first x)^(Tuple.second x)) waccs_time
-- my npv function
calcNPV : List Float -> Float -> Html text
calcNPV cfs wacc =
let
n = List.length cfs
df = calcDF wacc n
cfs_df = zip cfs df
in
List.map (\x -> (Tuple.first x) * (Tuple.second x)) cfs_df
|> List.foldl (+) 0
Example:
calcNPV [100,100,100] 0.1
-- returns 273.553719

Answer 1

I'm not sure why you want to use Maybes.
But as you suspected, you have made the current code more complex than needed. Here's a reworking of the first function. You want n discount values, so we start by creating something with n items to loop over and then just do the calculation in the map function
calcDF : Float -> Int -> List Float
calcDF wacc n =
List.range 0 n
|> List.map (calcDF_ wacc)
calcDF_ : Float -> Int -> Float
calcDF_ wacc idx =
1 / (1 + toFloat idx) ^ wacc
If you use https://package.elm-lang.org/packages/elm-community/list-extra/latest/List-Extra#indexedFoldl you could simplify the main function just to call calcDF_ while looping folding over cfs and skip calcDF altogether

Answer 2

With the help from Elm discourse forum (see here) I came up with the following solutions.
NPV calculation without type Maybe
calcNPV : List Float -> Float -> Float
calcNPV cashflows wacc =
let
time = List.length cashflows |> List.range 0 |> List.map toFloat
waccs = List.repeat (List.length cashflows) wacc
calcPV : Float -> Float -> Float -> Float
calcPV cf i t = cf / (1+i)^t
in
List.map3 calcPV cashflows waccs time |> List.foldl (+) 0
NPV calculation with type Maybe
calcMaybeNPV : List (Maybe Float) -> Maybe Float -> Maybe Float
calcMaybeNPV maybecashflows maybewacc =
let
time = List.length maybecashflows |> List.range 0 |> List.map (\x -> Just (toFloat x))
waccs = List.repeat (List.length maybecashflows) maybewacc
calcPV : Maybe Float -> Maybe Float -> Maybe Float -> Maybe Float
calcPV cf i t =
Maybe.map3 (\a b c -> a / (1+b)^c) cf i t
in
List.map3 calcPV maybecashflows waccs time |> List.foldl (Maybe.map2 (+)) (Just 0)