This tutorial main focus will be the `UIPageControlTimerProgress` class.
`UIPageControlTimerProgress` has been introduced in **iOS 17**, and it is also available in **tvOS 17**.
This class allows us to create timed paging really easily and with a relatively small amount of code.
## Visual
The new `UIPageControlTimerProgress` will display a `UIPageControl` as usual, but the current page indicator has a pill shape with a progress bar inside.
Once the progress bar is filled, the `UIPageViewController` will transition to the next page.
It is the same kind of behavior that we can see in apps like Instagram, Snapchat, and WhatsApp stories.
We have seen this behavior for a long time, but it is nice that Apple decided to introduce it eventually. 
## SwiftUI interoperability
Currently, it is available only for **UIKit**, but you can wrap the `UIPageViewController` in a `UIViewControllerRepresentable` struct and use it in your **SwiftUI** project.
Hopefully, Apple will eventually add it to **SwiftUI** as a style modifier for the `TabView`.
Now, let's see how to use it.
## Page control timer implementation
`UIPageControlTimerProgress` is not a`UIPageControl` in itself, but it has to be assigned to the `progress` property of the `UIPageControl` component.
To do so, let's start by creating the `ViewController` that will host the page controller.
```swift
class TimerPageViewController: UIPageViewController {
 
  /// This property will hold the pages to show.
  let pages: [PageVC]
}
```
> The `PageVC` code and the `UIPageViewController` implementation is [here](https://gist.github.com/francescoleoni98/7b58d5661b1c16e2f3e175507acf2a5e). I didn't include it in the tutorial since this isn't the main focus.
Then we create the `UIPageControlTimerProgress` component and assign it to the `UIPageControl`.
So, inside the `viewDidLoad` method add:
```swift
let timerProgress = UIPageControlTimerProgress(preferredDuration: 2)
timerProgress.delegate = self // we will configure this later
timerProgress.resetsToInitialPageAfterEnd = true
  
let pageControl = UIPageControl()
pageControl.progress = timerProgress
pageControl.numberOfPages = pages.count
 
// Add the page control to the view controller.
view.addSubview(pageControl)
NSLayoutConstraint.activate([
  pageControl.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
  pageControl.centerXAnchor.constraint(equalTo: view.centerXAnchor),
])
```
## UIPageControlTimerProgressDelegate
Then conform the `TimerPageViewController` to `UIPageControlTimerProgressDelegate` and implement the `pageControlTimerProgress(_:shouldAdvanceToPage:)` method.
```swift
extension TimerPageViewController: UIPageControlTimerProgressDelegate { 
 
 func pageControlTimerProgress(_ progress: UIPageControlTimerProgress, shouldAdvanceToPage page: Int) -> Bool {
    let nextPage = pages[page]
    self.setViewControllers([nextPage], direction: .forward, animated: true)
    return true
  }
}
```
This method is called every time the current progress of the `UIPageControlTimerProgress ` reaches the end and asks you whether it should advance to the next page.
Here we get the next view controller and set it to the **PageViewController** in order to show it.
Finally, we return `true` to tell the control that it can advance to the next page.
## Start the timer process page controller
The `UIPageControlTimerProgress` won't start automatically, but we need to do so by calling `resumeTimer()`.
I have found that the most useful place to start the timer is inside `viewDidAppear`, since inside `viewDidLoad` it won't have any effect. Maybe this is a bug that will be fixed in the public release.
```swift
override func viewDidAppear(_ animated: Bool) {
  super.viewDidAppear(animated)
  timerProgress.resumeTimer()
}
```
## Handle user interaction
As it is now, if the user swipes to the next page, the progress control won't go to the next indicator until it has finished with the current one.
To fix this behavior, we need to implement a method from the `UIPageViewControllerDelegate` protocol, called `pageViewController(_:willTransitionTo:)`.
This method is called as soon as the user starts scrolling.
```swift
class TimerPageViewController {
 
    // 1.
    var suspensionTimer: Timer? 
}
 
extension TimerPageViewController: UIPageViewControllerDelegate {
 
  func pageViewController(_ pageViewController: UIPageViewController, willTransitionTo pendingViewControllers: [UIViewController]) {
    // 2.
    timerProgress.pauseTimer()
    suspensionTimer?.invalidate()
     
    // 3.
    suspensionTimer = Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { _ in
      self.timerProgress.resumeTimer()
    }
  }
}
```
Here we:
1. Add a variable  that will hold the timer that handles user interactions
2. Pause the page control timer progress as soon as the user starts swiping
3. Start a timer for 2 seconds that will resume the progress page controller in case the user stops swiping through pages

This way, if the user swipes a page, the page control timer will pause and resume after 2 seconds.
And we are done with the new `UIPageControlTimerProgress ` component.
## Preview
To preview what we have done, you can use the new `#Preview` [macro](/articles/swift-macros) available in **Swift 5.9**.
```swift
#Preview {
  TimerPageViewController(pages: [PageVC(index: 0, image: "bergamo"),
                                  PageVC(index: 1, image: "venice"),
                                  PageVC(index: 2, image: "florence")])
}
```
Here is the result
![timed_carousel_swift.gif](https://media.graphassets.com/GBIGvs0QTwOkthSMMOl2)
## Complete code
[Here](https://gist.github.com/francescoleoni98/7b58d5661b1c16e2f3e175507acf2a5e) you can find the complete code.
## Conclusion
This implementation is not written anywhere else since it is a new component and Apple didn't provide any sample code, as far as I know.
So, if you have any suggestions on how to improve it, let me know [here](https://twitter.com/franceleonidev), I will really appreciate it.
`UIPageControlTimerProgress` is a really cool feature that Apple introduced in iOS 17.
It makes it clearer to the user that the slideshow is animated and how long each page will last.

Learn how to create a page controller that automatically changes page with the new UIPageControlTimerProgress component.

Tutorial: How to Create a Timed Paging Carousel Like Instagram

**Swift 5.9** introduces some improvements that will allow a more clear and less tedious to write code.

This changes affect `if else` and `switch` statements.

Let's see them more in detail.
## If-else
The `ternary syntax` is really handy and allows us to return a result based on a condition in a `let` statement. 
This is really useful in simple cases that involves only one condition but if there are more nested conditions it can become really hard to read, like the example below.
```swift
let bullet = isRoot && (count == 0 || !willExpand) ? ""
             : count == 0 ? "- "
             : maxDepth <= 0 ? "▹ " : "▿ "
```
To make the above code more readable we could wrap it in a `closure` and use `if else` statements. But in this case we should use the `return` keyword every time we need to return a value.
```swift
let bullet = {
    if isRoot && (count == 0 || !willExpand) { return "" }
    else if count == 0 { return "- " }
    else if maxDepth <= 0 { return "▹ " }
    else { return "▿ " }
}()
```
The new syntax avoids all of these problems.
Now the `if else` statement can start right after the `let` declaration without any `closure` or `ternary syntax`.
```swift
let bullet = if isRoot && (count == 0 || !willExpand) { "" }
             else if count == 0 { "- " }
             else if maxDepth <= 0 { "▹ " }
             else { "▿ " }
```
The new syntax allows `return` keyword omission but, if you prefer, you can still add `return` wherever you need it.
Of course you can still use the two techniques above in **Swift 5.9** if you wish.

## Switch
So far Swift has allowed us to omit the `return` keyword in `func`s and computed `var`s when the body is a single expression, however we must use the `return` keyword in `switch` statements if we need to return a value. 

This was needed up until now.

With **Swift 5.9** you can omit the `return` keyword even in `switch` statements!

```swift
enum Color {
 
  case red
  case green
  case blue
 
  var color: Color {
    switch self {
    case .red: Color.red
    case .green: Color.green
    case .blue: Color.blue
    }
  }
}
```

```swift
func width(_ x: Unicode.Scalar) -> Int {
  switch x.value {
  case 0..<0x80: 1
  case 0x80..<0x0800: 2
  case 0x0800..<0x1_0000: 3
  default: 4
  }
}
```
## Resources
Some examples in this article are taken from [SE-0380](https://github.com/apple/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md).
## Conclusion
These are really nice additions to **Swift 5.9** that will improve the syntax and will make our code more readable and less tedious to write.

Improve your code with inline if-else and switch statements available in Swift 5.9. Make your codebase less tedious to write.

Make Code Easier to Write and Read in Swift 5.9

## What are Macros?
Swift Macros allow you to generate repetitive code at compile time, making your app's codebase more easier to read and less tedious to write.

There are two types of macros: 
* **Freestanding** macros stand in place of something else in your code. They always start with a **hashtag** (#) sign. 
```swift
#caseDetection // Freestanding Macro
```
* **Attached** macros are used as attributes on declarations in your code. They start with an **@** sign.
```swift
@CaseDetection // Attached Macro
```

## Create new Macro
Macros need to be created in a special `Package` that depends on `swift-syntax` library.
!NOTE SwiftSyntax is a set of Swift libraries for parsing, inspecting, generating, and transforming Swift source code. Here is the [GitHub repo](https://github.com/apple/swift-syntax.git).
To create a new Macro go to `New -> Package` and select `Swift Macro`.
Type the name of your Macro and create the `Package`.
!NOTE Type only the actual name of the macro, without Macro suffix. Eg. for a Macro named **AddAsync**, type **AddAsync** not **AddAsyncMacro**.

## Macro Package structure
Inside the newly created `Package` you will find some auto-generated files:
* `[Macro name].swift` where you declare the signature of your Macro
* `main.swift` where you can test the behaviour of the Macro
* `[Macro name]Macro.swift` where you write the actual implementation of the Macro 
* `[Macro name]Tests.swift`  where you write the tests of the Macro implementation

## Macro roles
A single Macro can have multiple roles that will define its behaviour.
The available roles are:
### @freestanding(expression)
Creates a piece of code that returns a value.
#### Protocol
`ExpressionMacro`
#### Declaration
```swift
@freestanding(expression)
```
 
### @freestanding(declaration)
Creates one or more declarations. Like `struct`, `function`, `variable` or `type`.
#### Protocol
`DeclarationMacro`
#### Declaration
```swift
@freestanding (declaration, names: arbitrary)
```
 
### @attached(peer)
Adds new declarations alongside the declaration it's applied to.
#### Protocol
`PeerMacro`
#### Declaration
```swift
@attached(peer, names: overloaded)
```
 
### @attached(accessor)
Adds accessors to a property. Eg. adds `get` and `set` to a `var`. For example the `@State` in SwiftUI.
#### Protocol
`AccessorMacro`
#### Declaration
```swift
@attached(accessor)
```
 
### @attached (memberAttribute)
Adds attributes to the declarations in the type/extension it's applied to.
#### Protocol
`MamberAttributeMacro`
#### Declaration
```swift
@attached(memberAttribute)
```
 
### @attached (member)
Adds new declarations inside the type/extension it's applied to. Eg. adds a custom `init()` inside a `struct`.
#### Protocol
`MemberMacro`
#### Declaration
```swift
@attached(member, names: named(init()))
```
 
### @attached(conformance)
Adds conformances to protocols.
#### Protocol
`ConformanceMacro`
#### Declaration
```swift
@attached(conformance)
```

## Build Macro
### Signature
In this guide we will create a **Macro** that creates an `async` function off of a `completion` one.
To start building this Macro we need to create the Macro **signature**.
To do this, go to `[Macro name].swift` file and add.
```swift
@attached(peer, names: overloaded)
public macro AddAsync() = #externalMacro(module: "AddAsyncMacros", type: "AddAsyncMacro")
```
Here you declare the name of the Macro (`AddAsync`), then in the `#externalMacro` you specify the module it is in and the type of the Macro.
### Implementation
Then to implement the actual Macro, go to the `[Macro name]Macro.swift` file.
Create a `public struct` named accordingly with the name of the Macro and add conformance to protocols based on the signature you specified in the `Macro signature`. 
So, inside newly created `struct` and add the required method.
```swift
public struct AddAsyncMacro: PeerMacro {
  
   public static func expansion(of node: AttributeSyntax, providingPeersOf declaration: some DeclSyntaxProtocol, in context: some MacroExpansionContext) throws -> [DeclSyntax] {
      // Implement macro
   }
}
```
If your `Macro signature` has more than one role you need to add conformance to each role, for example:
```swift
// Signature
@attached(accessor)
@attached(memberAttribute)
@attached(member, names: named(init()))
public macro // ...
 
// Implementation
public struct MyMacro: AccessorMacro, MamberAttributeMacro, MemberMacro { }
```
!NOTE To know the corresponding protocols see [Macro roles](/articles/swift-macros#Macro%20roles) section.
### Exporting the Macro
Inside `[Macro name]Macro.swift` file add or edit this piece of code with to newly created Macro.
```swift
@main
struct AddAsyncMacroPlugin: CompilerPlugin {
  let providingMacros: [SwiftSyntaxMacros.Macro.Type] = [
    AddAsyncMacro.self
  ]
}
```
### Expansion method
The expansion method is responsible for generating the hidden code.
Here the piece of code the **Macro** (`declaration`) is attached on, is broken into pieces (`TokenSyntax`) and manipulated to generate the desired additional code.

To do this we have to cast the `declaration` to the desired syntax. 
Eg. If the Macro can be attached to a `struct` we will cast it to `StructDeclSyntax`.
In this case the Macro can only be attached to a `function` so we will cast it to `FunctionDeclSyntax`.
So, inside the `expansion` method add:
```swift
guard let functionDecl = declaration.as(FunctionDeclSyntax.self) else {
   // TODO: Throw error
}
 
return []
```
Now, before we continue, we need to write a test that checks whether the implementation of the Macro generates the code we expect.
So, in `[Macro name]Tests.swift` file add:
```swift
func test_AddAsync() {
    assertMacroExpansion(
        """
        @AddAsync
        func test(arg1: String, completion: (String?) -> Void) {
          
        }
        """,
        expandedSource: """
        
        func test(arg1: String, completion: (String?) -> Void) {
          
        }
        
        func test(arg1: String) async -> String? {
          await withCheckedContinuation { continuation in
            self.test(arg1: arg1) { object in
              continuation.resume(returning: object)
            }
          }
        }
        """,
        macros: testMacros
    )
}
```
Once that is in place, let's add a breakpoint at `return []` inside the `expansion` method and run the test.
Once we hit the breakpoint, run `po functionDecl` inside the debug console to get this long description:
```terminal
FunctionDeclSyntax
├─attributes: AttributeListSyntax
│ ╰─[0]: AttributeSyntax
│   ├─atSignToken: atSign
│   ╰─attributeName: SimpleTypeIdentifierSyntax
│     ╰─name: identifier("AddAsync")
├─funcKeyword: keyword(SwiftSyntax.Keyword.func)
├─identifier: identifier("test")
├─signature: FunctionSignatureSyntax
│ ╰─input: ParameterClauseSyntax
│   ├─leftParen: leftParen
│   ├─parameterList: FunctionParameterListSyntax
│   │ ├─[0]: FunctionParameterSyntax
│   │ │ ├─firstName: identifier("arg1")
│   │ │ ├─colon: colon
│   │ │ ├─type: SimpleTypeIdentifierSyntax
│   │ │ │ ╰─name: identifier("String")
│   │ │ ╰─trailingComma: comma
│   │ ╰─[1]: FunctionParameterSyntax
│   │   ├─firstName: identifier("completion")
│   │   ├─colon: colon
│   │   ╰─type: FunctionTypeSyntax
│   │     ├─leftParen: leftParen
│   │     ├─arguments: TupleTypeElementListSyntax
│   │     │ ╰─[0]: TupleTypeElementSyntax
│   │     │   ╰─type: OptionalTypeSyntax
│   │     │     ├─wrappedType: SimpleTypeIdentifierSyntax
│   │     │     │ ╰─name: identifier("String")
│   │     │     ╰─questionMark: postfixQuestionMark
│   │     ├─rightParen: rightParen
│   │     ╰─output: ReturnClauseSyntax
│   │       ├─arrow: arrow
│   │       ╰─returnType: SimpleTypeIdentifierSyntax
│   │         ╰─name: identifier("Void")
│   ╰─rightParen: rightParen
╰─body: CodeBlockSyntax
  ├─leftBrace: leftBrace
  ├─statements: CodeBlockItemListSyntax
  ╰─rightBrace: rightBrace
```
Here you can see every component of the function declaration.
And now you can pick the individual piece you need and use it to create you Macro-generated code.
### Retrieve first argument name
For example, if you need to retrieve the first argument name of the function, you will write:
```swift
let signature = functionDecl.signature.as(FunctionSignatureSyntax.self)
let parameters = signature?.input.parameterList
let firstParameter = parameters?.first
let parameterName = firstParameter.firstName // -> arg1
```
This is quite a long code just to retrieve a single string and it will be even more complex if you need to handle multiple function variations.
I think that Apple will improve this in the future, but for now let's stick with this.
### Complete the implementation 
Now, let's complete the `AddAsync` implementation.
```swift
if let signature = functionDecl.signature.as(FunctionSignatureSyntax.self) {
   let parameters = signature.input.parameterList
      
   // 1.
   if let completion = parameters.last,
      let completionType = completion.type.as(FunctionTypeSyntax.self)?.arguments.first,
   let remainPara = FunctionParameterListSyntax(parameters.removingLast()) {
        
   // 2. returns "arg1: String"
   let functionArgs = remainPara.map { parameter -> String in
      guard let paraType = parameter.type.as(SimpleTypeIdentifierSyntax.self)?.name else { return "" }
      return "\(parameter.firstName): \(paraType)"
   }.joined(separator: ", ")
        
   // 3. returns "arg1: arg1"
   let calledArgs = remainPara.map { "\($0.firstName): \($0.firstName)" }.joined(separator: ", ")
        
   // 4.
   return [
   """
   func \(functionDecl.identifier)(\(raw: functionArgs)) async -> \(completionType) {
      await withCheckedContinuation { continuation in
         self.\(functionDecl.identifier)(\(raw: calledArgs)) { object in
            continuation.resume(returning: object)
         }
      }
   }
   """
   ]
}
```
In this block of code we:
1. Retrieve the completion argument from the function signature
2. Parse the function arguments except the completion
3. Create the arguments that get passed into the called function
4. Compose the async function

## Show custom errors
Macros allow you to show custom errors to the user.
For example, in case the user placed the macro on a `struct` but that macro can only be used with `functions`.
In this case, you can throw an error and it will be automatically shown in Xcode.
```swift
enum AsyncError: Error, CustomStringConvertible {
  
  case onlyFunction
  
  var description: String {
    switch self {
    case .onlyFunction:
      return "@AddAsync can be attached only to functions."
    }
  }
}
 
// Inside `expansion` method. 
guard let functionDecl = declaration.as(FunctionDeclSyntax.self) else {
   throw AsyncError.onlyFunction // <- Error thrown here
}
```

## Test Macro usage
To test the behaviour of the `AddAsync` macro.
Go to the `main.swift` file and add:
```swift
struct AsyncFunctions {
  
  @AddAsync
  func test(arg1: String, completion: (String) -> Void) {
    
  }
}
 
func testing() async {
  let result = await AsyncFunctions().test(arg1: "Blob")
}
```
As you can see the build completes with success.
!WARNING The autocompletion may not show the generated async function.
## Show Macro generated code
To expand a Macro in code and see the automatically generated code, `right click` on the Macro and choose `Expand Macro` from the menu.
!WARNING The `Expand Macro` seems to not work always in Xcode 15.0 beta (15A5160n).
## Breakpoint
Code generated by Macros can be debugged by adding breakpoints as you normally would.
To do this, `right click` on a Macro and choose `Expand Macro` from the menu.
Then add a breakpoints at the line you wish to debug.
## Conclusion
Congratulations! You just created your first Macro.
Check out [here](https://github.com/francescoleoni98/Swift-Macros-AddAsync-example) the complete code.
As you saw, so far Macro implementations can be quite long event to perform a simple task.
But once you wrap your head around, they can be really useful and they can save you a lot of boilerplate code.
Macros are still in Beta so I think Apple will improve them by the time they will be available publicly.

Discover the new Swift Macro, speed up your workflow and make your code easier to read. Available for Swift 5.9 and Xcode 15.

How to Create Swift Macros with Xcode 15

[FLCharts](https://github.com/francescoleoni98/FLCharts) is a flexible, easy-to-use third-party library, allowing you to highly customise your chart.
FLCharts is an easy-to-use library to build highly customizable bar charts. It allows you to create your own chart bar.
Here I used some gas consumptions data to demonstrate how to set up a basic bar chart using `FLCharts`.
## Install
You can install `FLCharts` through [Cocoapods](https://cocoapods.org) or [Swift Package Manager](https://www.swift.org/package-manager).
## Setting Up a Chart View
Firstly, make sure to import `FLCharts` to the top of the file.
```swift
import FLCharts
```
## Setting Up Data
```swift
let monthsData = [MultiPlotable(name: "jan", values: [30]),
                  MultiPlotable(name: "feb", values: [55]),
                  MultiPlotable(name: "mar", values: [70]),
                  MultiPlotable(name: "apr", values: [45, 30]),
                  MultiPlotable(name: "may", values: [85]),
                  MultiPlotable(name: "jun", values: [46, 40]),
                  MultiPlotable(name: "jul", values: [75]),
                  MultiPlotable(name: "aug", values: [10]),
                  MultiPlotable(name: "set", values: [60]),
                  MultiPlotable(name: "oct", values: [75]),
                  MultiPlotable(name: "nov", values: [85]),
                  MultiPlotable(name: "dec", values: [55, 50, 20])]
```
Each `MultiPlotable` object represents the data of one month. The name value is the _name of the month_ on the x axis and the values property is their _consumptions on the y axis_.
```swift
let chartData = FLChartData(title: "Consumptions",
                            data: monthsData,
                            legendKeys: [Key(key: "F1", color: .Gradient.purpleCyan),
                                         Key(key: "F2", color: .green),
                                         Key(key: "F3", color: .Gradient.sunset)],
                            unitOfMeasure: "kWh")
```
Here, we are setting up the data for the chart.
`FLChartData` contains all the data the chart needs to configure itself.
The title is shown when the chart is embedded in a `FLCard`.
The legendKeys define the color of the sections of the bar and the keys of the legend, if it is embedded in a `FLCard`.
`FLCharts` has a collection of colors and gradients to use in your chart. And you can create your own using the `FLColor` struct.
## Creating chart
Then we create the actual chart with this simple line of code.
```swift
let chart = FLChart(data: chartData, type: .bar())
```
!TIP The bar chart allows you to create your own bar view simply creating a class that conforms to `ChartBar` protocol.
Now we have to layout the chart, in this example we will do it using AutoLayout.
```swift
view.addSubview(chart)
chart.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    chart.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    chart.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    chart.heightAnchor.constraint(equalToConstant: 300),
    chart.widthAnchor.constraint(equalToConstant: 330)
])
```
And here is our bar chart.
![final](/flcharts/flchart.jpeg)
## Embed chart inside FLCard
Now, we can embed the chart inside a card.
```swift
let card = FLCard(chart: chart, style: .rounded)
card.showAverage = true
card.showLegend = false
```
This is all we need for this task.
As you may notice `FLCard` has some additional properties and the ability to customize the card itself through the `style` property.
`FLCharts` has two predefined styles: `.plain` and `.rounded`, but you can create your own using the `FLCardStyle` struct.
There is just one last thing to change in order to show the card. We must replace `chart` with `card` in the auto layout code.
```swift
view.addSubview(card)
card.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    card.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    card.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    card.heightAnchor.constraint(equalToConstant: 300),
    card.widthAnchor.constraint(equalToConstant: 330)
])
```
## Final result
![final](/flcharts/consumptions.jpeg)
## Highlight view
`FLCharts` allows you to display a view when tapping on a bar. The library has a default one but you can create your own creating a `class` that conforms to the protocol `HighlightedView`.
Here's an example:
![highlight](/flcharts/highlight.gif)
## Additional features
`FLCharts` has additional properties the allows you to further customize your charts.
You can assign your own configuration through the `config` property:
```swift
chart.config = FLChartConfig(granularityY: 20)
```
## Aware x FLCharts
[Aware - Daily Bullet Journal](https://apps.apple.com/app/aware-daily-bullet-journal/id1560309401?l=en)
![aware](/flcharts/aware.jpeg)
## GitHub
Check out the library [here](https://github.com/francescoleoni98/FLCharts).
## Conclusion
For your time and attention! I hope you enjoyed this article and `FLCharts`.
If you have suggestions or feedbacks, they are really welcomed and they help me improve the library.

Create beautiful and highly customisable bar, line, radar charts and many more with FLCharts, a flexible, easy-to-use library.

Swift

Tutorial: How to Create a Timed Paging Carousel Like Instagram

Make Code Easier to Write and Read in Swift 5.9

How to Create Swift Macros with Xcode 15

FLCharts: Create Bar Chart easily