Swift 3 conversion, 2nd pass

glaurent · glaurent · commit 6a774fa9420f · 2016-09-08T20:23:09.000+02:00
Signed-off-by: Guillaume Laurent &lt;glaurent@telegraph-road.org&gt;
diff --git a/Source/Calculators/NoteCalculator.swift b/Source/Calculators/NoteCalculator.swift
@@ -17,16 +17,16 @@ public struct NoteCalculator {
   // MARK: - Bounds
 
   public static var indexBounds: (minimum: Int, maximum: Int) {
-    let minimum = try! index(frequency: Config.minimumFrequency)
-    let maximum = try! index(frequency: Config.maximumFrequency)
+    let minimum = try! index(Config.minimumFrequency)
+    let maximum = try! index(Config.maximumFrequency)
 
     return (minimum: minimum, maximum: maximum)
   }
 
   public static var octaveBounds: (minimum: Int, maximum: Int) {
     let bounds = indexBounds
-    let minimum = try! octave(index: bounds.minimum)
-    let maximum = try! octave(index: bounds.maximum)
+    let minimum = try! octave(bounds.minimum)
+    let maximum = try! octave(bounds.maximum)
 
     return (minimum: minimum, maximum: maximum)
   }
@@ -49,7 +49,7 @@ public struct NoteCalculator {
 
   // MARK: - Pitch Notations
 
-  public static func frequency(index: Int) throws -> Double {
+  public static func frequency(_ index: Int) throws -> Double {
     guard isValidIndex(index) else {
       throw PitchError.invalidPitchIndex
     }
@@ -60,7 +60,7 @@ public struct NoteCalculator {
     return pow(2, power) * Standard.frequency
   }
 
-  public static func letter(index: Int) throws -> Note.Letter {
+  public static func letter(_ index: Int) throws -> Note.Letter {
     guard isValidIndex(index) else {
       throw PitchError.invalidPitchIndex
     }
@@ -81,7 +81,7 @@ public struct NoteCalculator {
     return letters[lettersIndex]
   }
 
-  public static func octave(index: Int) throws -> Int {
+  public static func octave(_ index: Int) throws -> Int {
     guard isValidIndex(index) else {
       throw PitchError.invalidPitchIndex
     }
@@ -98,7 +98,7 @@ public struct NoteCalculator {
 
   // MARK: - Pitch Index
 
-  public static func index(frequency: Double) throws -> Int {
+  public static func index(_ frequency: Double) throws -> Int {
     guard PitchCalculator.isValidFrequency(frequency) else {
       throw PitchError.invalidFrequency
     }
@@ -108,7 +108,7 @@ public struct NoteCalculator {
     return Int(round(count * log2(frequency / Standard.frequency)))
   }
 
-  public static func index(letter: Note.Letter, octave: Int) throws -> Int {
+  public static func index(_ letter: Note.Letter, octave: Int) throws -> Int {
     guard isValidOctave(octave) else {
       throw PitchError.invalidOctave
     }
diff --git a/Source/Calculators/PitchCalculator.swift b/Source/Calculators/PitchCalculator.swift
@@ -27,21 +27,21 @@ public struct PitchCalculator {
       frequency: frequency - note.frequency,
       percentage: (frequency - note.frequency) * 100
         / abs(note.frequency - closestNote.frequency),
-      cents: try cents(frequency1: note.frequency, frequency2: frequency)
+      cents: try cents(note.frequency, frequency2: frequency)
     )
 
     let secondOffset = Pitch.Offset(
       note: closestNote,
       frequency: frequency - closestNote.frequency,
       percentage: (frequency - closestNote.frequency) * 100
         / abs(note.frequency - closestNote.frequency),
-      cents: try cents(frequency1: closestNote.frequency, frequency2: frequency)
+      cents: try cents(closestNote.frequency, frequency2: frequency)
     )
 
     return Pitch.Offsets(firstOffset, secondOffset)
   }
 
-  public static func cents(frequency1: Double, frequency2: Double) throws -> Double {
+  public static func cents(_ frequency1: Double, frequency2: Double) throws -> Double {
     guard isValidFrequency(frequency1)
       && isValidFrequency(frequency2)
       else { throw PitchError.invalidFrequency }
diff --git a/Source/Calculators/WaveCalculator.swift b/Source/Calculators/WaveCalculator.swift
@@ -11,8 +11,8 @@ public struct WaveCalculator {
 
   public static var periodBounds: (minimum: Double, maximum: Double) {
     let bounds = wavelengthBounds
-    let minimum = try! period(wavelength: bounds.minimum)
-    let maximum = try! period(wavelength: bounds.maximum)
+    let minimum = try! period(bounds.minimum)
+    let maximum = try! period(bounds.maximum)
 
     return (minimum: minimum, maximum: maximum)
   }
@@ -37,31 +37,31 @@ public struct WaveCalculator {
 
   // MARK: - Conversions
 
-  public static func frequency(wavelength: Double) throws -> Double {
+  public static func frequency(_ wavelength: Double) throws -> Double {
     guard isValidWavelength(wavelength) else {
       throw PitchError.invalidWavelength
     }
 
     return AcousticWave.speed / wavelength
   }
 
-  public static func wavelength(frequency: Double) throws -> Double {
+  public static func wavelength(frequency frequency: Double) throws -> Double {
     guard PitchCalculator.isValidFrequency(frequency) else {
       throw PitchError.invalidFrequency
     }
 
     return AcousticWave.speed / frequency
   }
 
-  public static func wavelength(period: Double) throws -> Double {
+  public static func wavelength(period period: Double) throws -> Double {
     guard isValidPeriod(period) else {
       throw PitchError.invalidPeriod
     }
 
     return period * AcousticWave.speed
   }
 
-  public static func period(wavelength: Double) throws -> Double {
+  public static func period(_ wavelength: Double) throws -> Double {
     guard isValidWavelength(wavelength) else {
       throw PitchError.invalidWavelength
     }
diff --git a/Source/Data/AcousticWave.swift b/Source/Data/AcousticWave.swift
@@ -27,7 +27,7 @@ public struct AcousticWave {
 
     self.frequency = frequency
     wavelength = try WaveCalculator.wavelength(frequency: frequency)
-    period = try WaveCalculator.period(wavelength: wavelength)
+    period = try WaveCalculator.period(wavelength)
   }
 
   public init(wavelength: Double) throws {
@@ -36,8 +36,8 @@ public struct AcousticWave {
     }
 
     self.wavelength = wavelength
-    frequency = try WaveCalculator.frequency(wavelength: wavelength)
-    period = try WaveCalculator.period(wavelength: wavelength)
+    frequency = try WaveCalculator.frequency(wavelength)
+    period = try WaveCalculator.period(wavelength)
   }
 
   public init(period: Double) throws {
@@ -47,6 +47,6 @@ public struct AcousticWave {
 
     self.period = period
     wavelength = try WaveCalculator.wavelength(period: period)
-    frequency = try WaveCalculator.frequency(wavelength: wavelength)
+    frequency = try WaveCalculator.frequency(wavelength)
   }
 }
diff --git a/Source/Data/Note.swift b/Source/Data/Note.swift
@@ -34,25 +34,25 @@ public struct Note {
 
   public init(index: Int) throws {
     self.index = index
-    letter = try NoteCalculator.letter(index: index)
-    octave = try NoteCalculator.octave(index: index)
-    frequency = try NoteCalculator.frequency(index: index)
+    letter = try NoteCalculator.letter(index)
+    octave = try NoteCalculator.octave(index)
+    frequency = try NoteCalculator.frequency(index)
     wave = try AcousticWave(frequency: frequency)
   }
 
   public init(frequency: Double) throws {
-    index = try NoteCalculator.index(frequency: frequency)
-    letter = try NoteCalculator.letter(index: index)
-    octave = try NoteCalculator.octave(index: index)
-    self.frequency = try NoteCalculator.frequency(index: index)
+    index = try NoteCalculator.index(frequency)
+    letter = try NoteCalculator.letter(index)
+    octave = try NoteCalculator.octave(index)
+    self.frequency = try NoteCalculator.frequency(index)
     wave = try AcousticWave(frequency: frequency)
   }
 
   public init(letter: Letter, octave: Int) throws {
     self.letter = letter
     self.octave = octave
-    index = try NoteCalculator.index(letter: letter, octave: octave)
-    frequency = try NoteCalculator.frequency(index: index)
+    index = try NoteCalculator.index(letter, octave: octave)
+    frequency = try NoteCalculator.frequency(index)
     wave = try AcousticWave(frequency: frequency)
   }
 

Original file line number	Diff line number	Diff line change
`@@ -17,16 +17,16 @@ public struct NoteCalculator {`
`17`	`17`	`// MARK: - Bounds`
`18`	`18`
`19`	`19`	`public static var indexBounds: (minimum: Int, maximum: Int) {`
`20`		`- let minimum = try! index(frequency: Config.minimumFrequency)`
`21`		`- let maximum = try! index(frequency: Config.maximumFrequency)`
	`20`	`+ let minimum = try! index(Config.minimumFrequency)`
	`21`	`+ let maximum = try! index(Config.maximumFrequency)`
`22`	`22`
`23`	`23`	`return (minimum: minimum, maximum: maximum)`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public static var octaveBounds: (minimum: Int, maximum: Int) {`
`27`	`27`	`let bounds = indexBounds`
`28`		`- let minimum = try! octave(index: bounds.minimum)`
`29`		`- let maximum = try! octave(index: bounds.maximum)`
	`28`	`+ let minimum = try! octave(bounds.minimum)`
	`29`	`+ let maximum = try! octave(bounds.maximum)`
`30`	`30`
`31`	`31`	`return (minimum: minimum, maximum: maximum)`
`32`	`32`	`}`
`@@ -49,7 +49,7 @@ public struct NoteCalculator {`
`49`	`49`
`50`	`50`	`// MARK: - Pitch Notations`
`51`	`51`
`52`		`- public static func frequency(index: Int) throws -> Double {`
	`52`	`+ public static func frequency(_ index: Int) throws -> Double {`
`53`	`53`	`guard isValidIndex(index) else {`
`54`	`54`	`throw PitchError.invalidPitchIndex`
`55`	`55`	`}`
`@@ -60,7 +60,7 @@ public struct NoteCalculator {`
`60`	`60`	`return pow(2, power) * Standard.frequency`
`61`	`61`	`}`
`62`	`62`
`63`		`- public static func letter(index: Int) throws -> Note.Letter {`
	`63`	`+ public static func letter(_ index: Int) throws -> Note.Letter {`
`64`	`64`	`guard isValidIndex(index) else {`
`65`	`65`	`throw PitchError.invalidPitchIndex`
`66`	`66`	`}`
`@@ -81,7 +81,7 @@ public struct NoteCalculator {`
`81`	`81`	`return letters[lettersIndex]`
`82`	`82`	`}`
`83`	`83`
`84`		`- public static func octave(index: Int) throws -> Int {`
	`84`	`+ public static func octave(_ index: Int) throws -> Int {`
`85`	`85`	`guard isValidIndex(index) else {`
`86`	`86`	`throw PitchError.invalidPitchIndex`
`87`	`87`	`}`
`@@ -98,7 +98,7 @@ public struct NoteCalculator {`
`98`	`98`
`99`	`99`	`// MARK: - Pitch Index`
`100`	`100`
`101`		`- public static func index(frequency: Double) throws -> Int {`
	`101`	`+ public static func index(_ frequency: Double) throws -> Int {`
`102`	`102`	`guard PitchCalculator.isValidFrequency(frequency) else {`
`103`	`103`	`throw PitchError.invalidFrequency`
`104`	`104`	`}`
`@@ -108,7 +108,7 @@ public struct NoteCalculator {`
`108`	`108`	`return Int(round(count * log2(frequency / Standard.frequency)))`
`109`	`109`	`}`
`110`	`110`
`111`		`- public static func index(letter: Note.Letter, octave: Int) throws -> Int {`
	`111`	`+ public static func index(_ letter: Note.Letter, octave: Int) throws -> Int {`
`112`	`112`	`guard isValidOctave(octave) else {`
`113`	`113`	`throw PitchError.invalidOctave`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@ public struct WaveCalculator {`
`11`	`11`
`12`	`12`	`public static var periodBounds: (minimum: Double, maximum: Double) {`
`13`	`13`	`let bounds = wavelengthBounds`
`14`		`- let minimum = try! period(wavelength: bounds.minimum)`
`15`		`- let maximum = try! period(wavelength: bounds.maximum)`
	`14`	`+ let minimum = try! period(bounds.minimum)`
	`15`	`+ let maximum = try! period(bounds.maximum)`
`16`	`16`
`17`	`17`	`return (minimum: minimum, maximum: maximum)`
`18`	`18`	`}`
`@@ -37,31 +37,31 @@ public struct WaveCalculator {`
`37`	`37`
`38`	`38`	`// MARK: - Conversions`
`39`	`39`
`40`		`- public static func frequency(wavelength: Double) throws -> Double {`
	`40`	`+ public static func frequency(_ wavelength: Double) throws -> Double {`
`41`	`41`	`guard isValidWavelength(wavelength) else {`
`42`	`42`	`throw PitchError.invalidWavelength`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`return AcousticWave.speed / wavelength`
`46`	`46`	`}`
`47`	`47`
`48`		`- public static func wavelength(frequency: Double) throws -> Double {`
	`48`	`+ public static func wavelength(frequency frequency: Double) throws -> Double {`
`49`	`49`	`guard PitchCalculator.isValidFrequency(frequency) else {`
`50`	`50`	`throw PitchError.invalidFrequency`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`return AcousticWave.speed / frequency`
`54`	`54`	`}`
`55`	`55`
`56`		`- public static func wavelength(period: Double) throws -> Double {`
	`56`	`+ public static func wavelength(period period: Double) throws -> Double {`
`57`	`57`	`guard isValidPeriod(period) else {`
`58`	`58`	`throw PitchError.invalidPeriod`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`return period * AcousticWave.speed`
`62`	`62`	`}`
`63`	`63`
`64`		`- public static func period(wavelength: Double) throws -> Double {`
	`64`	`+ public static func period(_ wavelength: Double) throws -> Double {`
`65`	`65`	`guard isValidWavelength(wavelength) else {`
`66`	`66`	`throw PitchError.invalidWavelength`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public struct AcousticWave {`
`27`	`27`
`28`	`28`	`self.frequency = frequency`
`29`	`29`	`wavelength = try WaveCalculator.wavelength(frequency: frequency)`
`30`		`- period = try WaveCalculator.period(wavelength: wavelength)`
	`30`	`+ period = try WaveCalculator.period(wavelength)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public init(wavelength: Double) throws {`
`@@ -36,8 +36,8 @@ public struct AcousticWave {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`self.wavelength = wavelength`
`39`		`- frequency = try WaveCalculator.frequency(wavelength: wavelength)`
`40`		`- period = try WaveCalculator.period(wavelength: wavelength)`
	`39`	`+ frequency = try WaveCalculator.frequency(wavelength)`
	`40`	`+ period = try WaveCalculator.period(wavelength)`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public init(period: Double) throws {`
`@@ -47,6 +47,6 @@ public struct AcousticWave {`
`47`	`47`
`48`	`48`	`self.period = period`
`49`	`49`	`wavelength = try WaveCalculator.wavelength(period: period)`
`50`		`- frequency = try WaveCalculator.frequency(wavelength: wavelength)`
	`50`	`+ frequency = try WaveCalculator.frequency(wavelength)`
`51`	`51`	`}`
`52`	`52`	`}`