3

I want to create a function which has a number parameter that should be between 0..100 %

I thought that the best way to enforce this would be by creating a wrapper type using FloatingPointType protocol , but I am getting a compilation error

Protocol 'FloatingPointType' can only be used as a generic constraint because it has Self or associated type requirements

struct Percent {
    init(val : FloatingPointType) {
        // enforce value is between 0..100
    }
}


func hideView(percent : Percent) {
  // percent is 0..100 at this point
.. do some work here
}

What would be the correct way to enforce this condition at compile time?

Ian
  • 12,538
  • 5
  • 43
  • 62
Avba
  • 14,822
  • 20
  • 92
  • 192

4 Answers4

4

Update: As of Swift 5.1 this can more easily achieved with “property wrappers”, see for example “Implementing a value clamping property wrapper” on NSHipster.

The easiest way would be to define a type that holds a Double (or Float or Int) in the required range:

struct P {
    let val : Double
    init (val : Double) {
        // ...
    }
}

But if you want to treat different floating point types then you have to define a generic class

struct Percent<T : FloatingPointType> {
    let val : T
    init(val : T) {
       self.val = val
    }
}

To compare the values you need to require Equatable as well:

struct Percent<T : FloatingPointType where T: Equatable> {
    let val : T
    init(val : T) {
        if val < T(0) {
            self.val = T(0)
        } else if val > T(100) {
            self.val = T(100)
        } else {
            self.val = val
        }
    }
}

Example:

let p = Percent(val: 123.4)
println(p.val) // 100.0

Note that this requires that hideView() is generic as well:

func hideView<T>(percent : Percent<T>) {
    // percent.val has the type `T` and is in the range
    // T(0) ... T(100)
}
Martin R
  • 529,903
  • 94
  • 1,240
  • 1,382
  • I think that percent shouldn't be a generic struct , but am wondering if the argument to init could be a "number" type (I thought FloatingPointType would be an umbrella type) – Avba Apr 25 '15 at 12:39
  • @AvnerBarr: You can define an `init(val : T)`, but how would you store the value? You cannot declare a property `let : FloatingPointType`. – Martin R Apr 25 '15 at 13:12
  • Why is that? I dont understand the compilation error as the type is a protocol. – Avba Apr 25 '15 at 18:42
  • Storing a propert which implements a protocol seems valid – Avba Apr 25 '15 at 18:43
  • @AvnerBarr: As soon as the protocol has an associated type is does not work anymore. Try `protocol MyP { typealias T } ; var x : MyP`. – Compare http://stackoverflow.com/a/27726029/1187415. – Martin R Apr 25 '15 at 18:47
2

The language feature you are looking for is called Partial Functions. A partial function is a function that is not defined for all possible arguments of the specified type. For instance, they are available in Haskell or Scala - but they are not available in Swift.

So the best you can do is to check at runtime if the provided value lies within the valid range and act accordingly (e.g. raise an exception or return an error).

Leo
  • 37,640
  • 8
  • 75
  • 100
1

It sounds like you're trying to enforce, at compile time, that you can't pass a value outside the range 0.0 to 100.0 to a function. You can't do that.

What you can do is write your function to throw an exception if it is passed a value that's out of range, or display an error to the user and return if it's out of range.

Duncan C
  • 128,072
  • 22
  • 173
  • 272
0

Adding up to Martin's answer with updating for Swift 5:

struct Percentage<T: FloatingPoint> {
  let value: T
  init(value: T) {
    self.value = min(max(value, T(0)), T(100))
  } 
}

Usage site, you can define the generic type like:

func updateCircleWith(percentage: Percentage<CGFloat>) {
  // percentage.value will be between 0 and 100 here
  // of course the CGFloat(0) and CGFloat(100)
}
Okhan Okbay
  • 1,374
  • 12
  • 26