 // MARK: Point <-> Location <-> SlotIndex Calculation
 private extension GridLayer {
     func _point(for location: GridLayer.Location) -> CGPoint {
-        let x: CGFloat = self._horizontalAbsOffset(forGridPosition: location.column)
-        let y: CGFloat = self._verticalAbsOffset(forGridPosition: location.row)
-        return CGPoint(x: x, y: y)
+        return CGPoint(
+            x: self._horizontalAbsOffset(forGridPosition: location.column),
+            y: self._verticalAbsOffset(forGridPosition: location.row)
+        )
     }
     
     func _location(nearestTo point: CGPoint) -> GridLayer.Location {

    }
    
    // Private Helpers
    private func _horizontalGridPosition(for absOffset: CGFloat) -> CGFloat {
        return self._roundToSubdivision((absOffset / self.columnWidth) - self.gridInsetFactor)
    }
    
    private func _verticalGridPosition(for absOffset: CGFloat) -> CGFloat {
        return self._roundToSubdivision((absOffset / self.rowHeight) - self.gridInsetFactor)
    }
    
    private func _absOffset(nearestToAbsOffset absOffset: CGFloat, minAbsOffset: CGFloat, maxAbsOffset: CGFloat, absStepUnit: CGFloat) -> CGFloat {
        if absOffset <= minAbsOffset {
            return minAbsOffset

            maxAbsOffset: self._verticalAbsOffset(forGridPosition: CGFloat(self._zeroedNumOfRows)),
            absStepUnit: self.rowHeight
        )
        
        let nearestColumnAbsOffset: CGFloat = self._absOffset(
            nearestToAbsOffset: point.x,
            minAbsOffset: self._horizontalAbsOffset(forGridPosition: 0),
            maxAbsOffset: self._horizontalAbsOffset(forGridPosition: CGFloat(self._zeroedNumOfColumns)),
            absStepUnit: self.columnWidth
        )
        
        func roundToSubdiv(_ position: CGFloat) -> CGFloat {
            let invertedSubdivision: CGFloat = 1 / self.subdivision.rawValue
            return round(position * invertedSubdivision) / invertedSubdivision
        }
        
        let insetFactor: CGFloat = self.gridInsetFactor
        
        return (
            roundToSubdiv((nearestRowAbsOffset / self.rowHeight) - insetFactor),
            roundToSubdiv((nearestColumnAbsOffset / self.columnWidth) - insetFactor)
        )
    }
    
    // Helpers
