swift map filter reduce not working for $0.parameter swiftui

I am trying to get the sum of some elements from my list.
Every element has a Int property called quantity.

MyElement:

class EmbeddedElement : EmbeddedRealmObject {
    var totalPrice: Double = 0.0
    var discount: Double = 0.0
    var quantity: Int = 1
  }

I am trying to get the sum of the total price of the elements.

The myElementsList has unique elements.

The problem is that whenever I try to multiple the totalPrice value with $0.quantity it does not build. With the error:

The compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions

For example this does not work (when multiplying with $0.quantity):

Text("\((myElementsList.map({($0.totalPrice-($0.totalPrice*$0.discount/100))*$0.quantity}).reduce(0,+)), specifier: "%.2f") dollar ")

But multiplying by simple number 5 or any other number works fine:

Text("\((myElementsList.map({($0.totalPrice-($0.totalPrice*$0.discount/100))*5}).reduce(0,+)), specifier: "%.2f") dollar ")

Why this happens? It is because that $0.quantity its a Int value? I tried casting but nothing worked. Any solution?

You are multiplying doubles in the first part of the calc and everything in the calc should be Doubles. It works if you "initialise" the Int as a double, eg.

Double($0.quantity)

The maths works fine in playgrounds with this. It also is better to leave spaces around the operators also as I had a couple of flags on this.

class EmbeddedElement  {
var totalPrice: Double = 5.0
var discount: Double = 3.2
var quantity: Int = 1
}

let element = EmbeddedElement()

var array = Array(repeatElement(element, count: 500))

let sum = array.map {
	($0.totalPrice - ($0.totalPrice*$0.discount / 100)) * Double($0.quantity)
}.reduce(0,+)

With the static 5 in the second calc that works because it knows the calc is doubles and the result will be a double, so it effectively "initialises" the 5 as a double.

When dealing with prices and money you may want to look in to Decimal type as you can see with my simple example, doubles can lead to long decimal places and need for rounding which can cause minor discrepancies over a lot of values.

I guess the error you are seeing was vague as it is pretty complicated and the type system is struggling to provide something meaningful.

I think the code in the question is mostly correct. I cannot guarantee the math equation is right, but the code is sound. Here's how to troubleshoot

Take your initial code

Text("\((myElementsList.map({($0.totalPrice-($0.totalPrice*$0.discount/100))*$0.quantity}).reduce(0,+)), specifier: "%.2f") dollar ")

Let's break it down a bit into pieces so it can be examined, remove the formula, leaving the text formatting code

Text("\((    ), specifier: "%.2f") dollar ")

and then the equation

let y = myElementsList.map({($0.totalPrice-($0.totalPrice*$0.discount/100))*$0.quantity}).reduce(0,+))

ah - now issue is obvious; the error is multiplying a double by an Int as mentioned in my comment. Fixing the equation is easy! Cast the Int to a Double and then the calculation works.

let y = myElementsList.map({($0.totalPrice-($0.totalPrice*$0.discount/100))*Double($0.quantity)}).reduce(0,+)

Not too complex!

Then insert that back into the Text code

Text("\((y), specifier: "%.2f") dollar ")

And it works.

Note:

See the comment about using Doubles from currency in Hongtron's answer and my followup comment. Use Decimal128.

print(1.03 - 0.42)

outputs:

0.6100000000000001     (this is inaccurate!)

whereas

let a = Decimal128(floatLiteral: 1.03)
let b = Decimal128(floatLiteral: 0.42)
let c = a - b
print(c.decimalValue)

outputs:

0.61  (good!)

As mentioned in the comments you should use computed properties here, not only to help the compiler but also for getting code that is easier to understand.

Here I have changed the type of the stored properties from Double to Decimal so that is what is used in this answer.

First I created a computed property that calculates the amount, I also changed the handling of the discount in the formula since I think it reads better this way

extension EmbeddedElement {
    var netAmount: Decimal {
        totalPrice * (1 - discount / 100.0) * Decimal(quantity)
    }
}

Then we can use this in the view together with reduce() to calculate the total amount but once again I prefer a computed property for clarity instead of doing the calculation inside the Text component

var totalAmount: Decimal {
    myElementsList.reduce(0) { $0 + $1.netAmount }
}

So then we have a much more readable Text component

Text(totalAmount.formatted(.number.precision(.fractionLength(2))))

To simplify it even further the formatting style could be moved into a constant (here I also added rounding)

private let amountFormat = Decimal.FormatStyle
    .number
    .precision(.fractionLength(2))
    .rounded(rule: .awayFromZero)

With that the we get

Text(totalAmount.formatted(amountFormat))