Getting to Know Enum, Struct and Class Types in Swift

Getting to Know Enum, Struct and Class Types in Swift

Replace observe: Adam Rush up to date this tutorial for Xcode 10, iOS 12 and Swift four.2. Ray Repair wrote the unique.

Again in the times when there was solely Goal-C, encapsulation was restricted to working with courses. Nevertheless, in trendy iOS and macOS programming utilizing Swift, there are three decisions: enums, structs and courses.

Mixed with protocols, these varieties make it attainable to create superb issues. Whereas they share many widespread talents, these varieties even have necessary variations.

The target of this tutorial is to:

  • Offer you some expertise utilizing enums, structs and courses.
  • Grant you some instinct about when to use them.
  • Offer you an understanding of how every works.

When it comes to conditions, this tutorial assumes that you’ve a minimum of the fundamentals of Swift and some object-oriented programming expertise. If you would like to study the fundamentals of Swift checkout our Swift Apprentice E-book

It’s All About These Types

Three huge promoting factors of Swift are its security, velocity and simplicity.

Security implies that it’s troublesome to by chance write code that runs amok, corrupting reminiscence and producing hard-to-find bugs. Swift makes your work safer as a result of it tries to make it apparent when you’ve a bug by displaying you issues at compile time, fairly than hanging you out to dry at runtime.

The important thing to making this occur is the Swift sort system:

Diagram showing the six types in Swift

Swift varieties are highly effective, regardless of there being solely six of them. That’s proper – in contrast to many different languages which have actually dozens of built-in varieties, Swift solely has six.

These consist of 4 named varieties: protocol, enum, struct and class. There are two compound varieties as properly: tuple and perform.

There are these different issues that you simply may consider as primary varieties, corresponding to Bool, Int, UInt, Float, and so on. Nevertheless, these are literally constructed up from the named varieties and delivered as a part of the Swift Normal Library.

This tutorial focuses on the so-called named mannequin varieties, which include enum, struct and class.

Shapes With Scalable Vector Graphics (SVG)

As a working instance, you’ll construct a protected, speedy and easy SVG form (scalable vector graphics) rendering framework.

SVG is an XML-based vector picture format for 2D graphics. This specification has been an open commonplace developed by the W3C since 1999.

Getting Began

Create a brand new playground in Xcode to comply with alongside by selecting File ▸ New ▸ Playground… from the menu. Subsequent, select the platform as macOS and select the Clean template. Subsequent, identify it Shapes and select a location to reserve it, then click on Create to save the playground. Clear the file utterly, then enter the next:

import Basis

Your objective might be to render one thing like this:

<!DOCTYPE html>
<svg width=’250′ peak=’250′>
<rect x=’110.Zero’ y=’10.Zero’ width=’100.Zero’ peak=’130.Zero’ stroke=’teal’
fill=’aqua’ stroke-width=’5′ />
<circle cx=’80.Zero’ cy=’160.Zero’ r=’60.Zero’ stroke=’pink’ fill=’yellow’
stroke-width=’5′ />

Utilizing a WebKit view, it appears like this:


You’ll want a illustration for colours. SVG makes use of the CSS3 colour sort that may be specified as a reputation, RGB or HSL. For extra particulars, you’ll be able to learn the complete specification.

To make use of a shade in SVG, you specify it as an attribute of a part of your drawing — for instance, fill = ‘grey’. A simple strategy to this in Swift is to use a String — as in, let fill = “gray”.

Whereas utilizing String is straightforward and does the job, there are some main downsides:

  • It’s error susceptible. Any strings that aren’t a part of the colour spectrum will compile wonderful however not present up appropriately at runtime. For instance, “grey” spelled with an “e” doesn’t work.
  • Autocomplete gained’t show you how to discover legitimate shade names.
  • Whenever you move round a shade as a parameter, it won’t all the time be apparent that the string is a shade.

Utilizing Enums

Utilizing a customized sort solves these issues. In the event you’re coming from Cocoa Contact, you may assume to implement an encapsulated class like UIColor. Whereas utilizing a category design might work, Swift provides you extra decisions for a way to outline your mannequin.

With out typing something in simply but, first have a assume the way you may implement the colours as an enum.

You may assume to implement it, like so:

enum ColorName
case black
case silver
case grey
case white
case maroon
case pink
// and so forth.

The above works very equally to a set of C-style enums. Nevertheless, in contrast to C-style enums, Swift provides you the choice to specify a kind to symbolize every case.

Enumerations that explicitly specify a backing retailer sort are referred to as RawRepresentable, as a result of they routinely conform to RawRepresentable.

You possibly can specify the kind of ColorName as String, and you assign a worth to every case, like so:

enum ColorName: String
case black = “black”
case silver = “silver”
case grey = “gray”
case white = “white”
case maroon = “maroon”
case purple = “red”
// and so on.

Nevertheless, Swift does one thing particular for enums with a String illustration. For those who don’t specify what the case is equal to, the compiler routinely makes the string the identical because the identify of the case. That signifies that you solely want to write the case identify:

enum ColorName: String
case black
case silver
case grey
case white
case maroon
case purple
// and so forth.

You possibly can additional scale back your typing by separating the instances with commas utilizing the key phrase case simply as soon as.

Add the next code to the top of your playground:

enum ColorName: String
case black, silver, grey, white, maroon, purple, purple, fuchsia, inexperienced,
lime, olive, yellow, navy, blue, teal, aqua

Now, you’ve gotten a first-class customized sort and all of the goodness that comes with that.

let fill = ColorName.gray // ERROR: Misspelled shade names will not compile. Good!
let fill = ColorName.grey // Right names autocomplete and compile. Yay!


Enums in Swift are nice for holding an inventory of things corresponding to our instance record of colours. To make enums much more highly effective, Swift four.2 added a brand new protocol named CaseIterable that gives a set of all of the values of the conformer.

At compile time, Swift will routinely create an allCases property that’s an array of all of your enum instances, in the order you outlined them.

Utilizing CaseIterable could be very easy. All you might have to do is declare the conformance in the definition of ColorName as proven under:

enum ColorName: String, CaseIterable
case black, silver, grey, white, maroon, pink, purple, fuchsia, inexperienced,
lime, olive, yellow, navy, blue, teal, aqua

You possibly can then use the allCases property whose sort is [ColorName]. Add the next to the top of your playground:

for colour in ColorName.allCases
print(“I love the color (color).”)

Within the console, you’ll see 16 strains printed — one for each colour in ColorName.

Related Values

ColorName is sweet for named colours, however you may recall that CSS colours have a number of representations: named, RGB, HSL and extra.

Enums in Swift are nice for modeling issues which have one in every of quite a lot of representations, comparable to CSS shade, and every enum case could be paired with its personal knowledge. These knowledge are referred to as related values.

Outline CSSColor utilizing an enum by including the next to the top of your playground:

enum CSSColor
case named(identify: ColorName)
case rgb(pink: UInt8, inexperienced: UInt8, blue: UInt8)

With this definition, you give the CSSColor mannequin one among two states:

  1. It may be named, in which case the related knowledge is a ColorName worth.
  2. It may be rgb, in which case the related knowledge is three UInt8 (Zero-255) numbers for purple, inexperienced and blue.

Observe that this instance leaves out rgba, hsl and hsla instances for brevity.

Protocols and Strategies With an Enum

Any model type in Swift can adopt a protocol

As a result of CSSColor has related values, it’s more durable (although not unattainable) to make it conform to RawRepresentable. The simplest approach to get a string illustration out of the brand new enum is by making it conform to CustomStringConvertible.

The important thing to inter-operating with the Swift Normal Library is to undertake normal library protocols.

Add the next extension for CSSColor to the top of your playground:

extension CSSColor: CustomStringConvertible
var description: String
change self
case .named(let colorName):
return colorName.rawValue
case .rgb(let pink, let inexperienced, let blue):
return String(format: “#%02X%02X%02X”, pink, inexperienced, blue)

On this implementation, description switches upon self to decide if the underlying mannequin is a named or RGB sort. In every case, you change the colour to the required string format. The named case simply returns the string identify, whereas the RGB case returns the purple, inexperienced and blue values in the required format.

To see how this works, add the next to your playground:

let color1 = CSSColor.named(identify: .pink)
let color2 = CSSColor.rgb(purple: 0xAA, inexperienced: 0xAA, blue: 0xAA)

// prints color1 = pink, color2 = #AAAAAA
print(“color1 = (color1), color2 = (color2)”)

Every part is sort checked and confirmed right at compile time, in contrast to once you use solely String values to symbolize colours.

Word: When you might return to your earlier definition of CSSColor and modify it, you don’t have to. You’ve used an extension to re-open the colour sort and undertake a brand new protocol.

The extension type is good as a result of it makes what you outline absolutely specific, in order to conform to a given protocol. Within the case of CustomStringConvertible, you’re required to implement a getter for description.

Initializers With an Enum

Identical to courses and structs in Swift, you can even add customized initializers to enum. For instance, you can also make a customized initializer for grayscale values.

Add this extension to your playground:

extension CSSColor
init(grey: UInt8)
self = .rgb(purple: grey, inexperienced: grey, blue: grey)

Add the next to your playground:

let color3 = CSSColor(grey: 0xaa)
print(color3) // prints #AAAAAA

Now you can conveniently create grayscale colours!

Namespaces With Enum

Named varieties can act as a namespace to maintain issues organized and to reduce complexity. You created ColorName and CSSColor, and, but, ColorName is just ever used in the context of a CSSColor.

Wouldn’t it’s good for those who might nest ColorName inside the CSSColor mannequin?

Properly, you possibly can! Take away ColorName out of your playground and exchange it with the next code:

extension CSSColor
enum ColorName: String, CaseIterable
case black, silver, grey, white, maroon, purple, purple, fuchsia, inexperienced,
lime, olive, yellow, navy, blue, teal, aqua

This strikes ColorName into an extension on CSSColor. Now, ColorName is tucked away, and the internal sort is outlined on CSSColor.

Because it’s now nested, the for loop you created earlier wants to be up to date as nicely. Change it to the next:

for shade in CSSColor.ColorName.allCases
print(“I love the color (color).”)

Notice: One of many nice options of Swift is that the order in which you declare issues often doesn’t matter. The compiler scans the file a number of occasions and figures it out without having to ahead declare issues because it does when working with C/C++/Goal-C.

Nevertheless, when you obtain an error in your playground about ColorName being an undeclared sort, transfer the above extension to slightly below your enum definition of CSSColor to clear the playground error.

Typically, playgrounds are delicate to the ordering of definitions, even when it doesn’t actually matter.

Taking Inventory of Enums

Enums are rather more highly effective in Swift than they’re in different languages, resembling C or Goal-C. As you’ve seen, you’ll be able to prolong them, create customized initializer strategies, present namespaces and encapsulate associated operations.

Up to now, you’ve used enum to mannequin CSS colours. This works nicely as a result of CSS colours are a nicely understood, fastened W3C specification.

Enumerations are nice for selecting gadgets from an inventory of well-known issues, comparable to days of the week, faces of a coin or states in a state machine. It’s no shock that Swift optionals are carried out in phrases of an enum with a state of .none or .some with an related worth.

However, in case you needed CSSColor to be consumer extensible to different shade area fashions that aren’t outlined in the W3C specification, an enumeration shouldn’t be probably the most helpful method of modeling colours.

That brings you to the subsequent Swift named mannequin sort: buildings or structs.

Utilizing Structs

Since you need your customers to have the ability to outline their very own customized shapes inside the SVG, utilizing an enum shouldn’t be a sensible choice for outlining form varieties.

You can’t add new enum instances later in an extension. To allow that conduct, you have got to use both a category or a struct.

The Swift Normal Library staff means that, if you create a brand new mannequin, you must first design the interface utilizing a protocol. You need your shapes to be drawable, so add this to your playground:

protocol Drawable
func draw(with context: DrawingContext)

The protocol defines what it means to be Drawable. It has a draw technique that pulls to one thing referred to as a DrawingContext.

Talking of DrawingContext, it’s simply one other protocol. Add it to your playground as follows:

protocol DrawingContext
func draw(_ circle: Circle)

A DrawingContext is aware of how to draw pure geometric varieties: Circle, Rectangle and different primitives. Pay attention to one thing right here: the precise drawing know-how is just not specified, however you may implement it in phrases of something — SVG, HTML5 Canvas, Core Graphics, OpenGL, Metallic, and so forth.

You’re prepared to outline a circle that adopts the Drawable protocol. Add this to your playground:

struct Circle: Drawable
var strokeWidth = 5
var strokeColor = CSSColor.named(identify: .pink)
var fillColor = CSSColor.named(identify: .yellow)
var middle = (x: 80.Zero, y: 160.Zero)
var radius = 60.Zero

// Adopting the Drawable protocol.

func draw(with context: DrawingContext)

Any sort that conforms to DrawingContext now is aware of how to draw a Circle.

Dynamic Member Lookup

Swift four.2 introduces a method to convey Swift lots nearer to scripting languages resembling Python. You don’t lose any of Swift’s security, however you do achieve the power to write the type of code you’re extra doubtless to see in Python.

Inside this new function is a brand new attribute referred to as @dynamicMemberLookup. This can name a subscript technique when making an attempt to entry the properties.

Substitute your present Circle implementation with the next:

struct Circle: Drawable
var strokeWidth = 5
var strokeColor = CSSColor.named(identify: .purple)
var fillColor = CSSColor.named(identify: .yellow)
var middle = (x: 80.Zero, y: 160.Zero)
var radius = 60.Zero

// Adopting the Drawable protocol.

func draw(with context: DrawingContext)

With the above, you might have outlined the brand new @dynamicMemberLookup attribute to the Circle struct. This requires Circle to implement subscript(dynamicMember:) technique to deal with the implementation of your @dynamicMemberLookup.

Add the next contained in the Circle struct:

subscript(dynamicMember member: String) -> String
let properties = [“name”: “Mr Circle”]
return properties[member, default: “”]

Now you can entry the identify, hard-coded to “Mr Circle”, of your Circle by including the next code:

let circle = Circle()
let circleName = circle.identify

In any case, all shapes have names. :]

The Dynamic Member Lookup attribute could be added to a category, struct, enum or protocol declaration.

Structs work so much like courses with a few key variations. Maybe the most important distinction is that structs are worth varieties and courses are reference varieties. Now what does that imply?!

Worth vs. Reference Types


Worth varieties work as separate and distinct entities. The quintessential worth sort is an integer as a result of it really works that method in most programming languages.

If you’d like to understand how a worth sort acts, ask the query, “What would Int do?” For instance:

For Int:

var a = 10
var b = a
a = 30 // b nonetheless has the worth of 10
a == b // false

For Circle (outlined utilizing struct):

var a = Circle()
a.radius = 60.Zero
var b = a
a.radius = 1000.Zero // b.radius nonetheless has the worth 60.Zero


Should you had made your circle from a category sort, it will have been given reference semantics. That signifies that it references an underlying shared object.

For Circle (outlined utilizing class):

let a = Circle() // a category based mostly circle
a.radius = 60.Zero
let b = a
a.radius = 1000.Zero // b.radius additionally turns into 1000.Zero

When creating new objects utilizing worth varieties, copies are made; when utilizing reference varieties, the brand new variable refers to the identical object. This dissimilarity in conduct is a important distinction between class and struct.

Rectangle Mannequin

Your Circle is a bit lonely at present, so it’s time to add a Rectangle mannequin:

struct Rectangle: Drawable
var strokeWidth = 5
var strokeColor = CSSColor.named(identify: .teal)
var fillColor = CSSColor.named(identify: .aqua)
var origin = (x: 110.Zero, y: 10.Zero)
var measurement = (width: 100.Zero, peak: 130.Zero)

func draw(with context: DrawingContext)

You additionally want to replace the DrawingContext protocol in order that it is aware of how to draw a rectangle. Substitute DrawingContext in your playground with the next:

protocol DrawingContext
func draw(_ circle: Circle)
func draw(_ rectangle: Rectangle)

Circle and Rectangle undertake the drawable protocol. They defer the precise work to one thing that conforms to the DrawingContext protocol.

Now, it’s time to make a concrete mannequin that pulls in SVG fashion. Add this to your playground:

last class SVGContext: DrawingContext
personal var instructions: [String] = []

var width = 250
var peak = 250

// 1
func draw(_ circle: Circle)
let command = “””
<circle cx='(circle.middle.x)’ cy='(circle.middle.y)’ r='(circle.radius)’
stroke='(circle.strokeColor)’ fill='(circle.fillColor)’
stroke-width='(circle.strokeWidth)’ />

// 2
func draw(_ rectangle: Rectangle)
let command = “””
<rect x='(rectangle.origin.x)’ y='(rectangle.origin.y)’
width='(rectangle.measurement.width)’ peak='(rectangle.measurement.peak)’
stroke='(rectangle.strokeColor)’ fill='(rectangle.fillColor)’
stroke-width='(rectangle.strokeWidth)’ />

var svgString: String
var output = “<svg width='(width)’ height='(height)’>”
for command in instructions
output += command

output += “</svg>”
return output

var htmlString: String
return “<!DOCTYPE html><html><body>” + svgString + “</body></html>”

SVGContext is a category that wraps a personal array of command strings. In sections 1 and 2, you conform to the DrawingContext protocol, and the draw strategies append a string with the right XML for rendering the form.

Lastly, you want a doc sort that may include many Drawable objects, so add this to your playground:

struct SVGDocument
var drawables: [Drawable] = []

var htmlString: String
let context = SVGContext()
for drawable in drawables
drawable.draw(with: context)

return context.htmlString

mutating func append(_ drawable: Drawable)

Right here, htmlString is a computed property on SVGDocument that creates an SVGContext and returns the string with HTML from the context.

Present Me Some SVG

How about you lastly draw an SVG? Add this to your playground:

var doc = SVGDocument()

let rectangle = Rectangle()

let circle = Circle()

let htmlString = doc.htmlString

This code creates a default circle and rectangle, and it places them right into a doc. It then prints the XML. Add the next to the top of the playground to see the SVG in motion:

import WebKit
import PlaygroundSupport
let view = WKWebView(body: CGRect(x: Zero, y: Zero, width: 300, peak: 300))
view.loadHTMLString(htmlString, baseURL: nil)
PlaygroundPage.present.liveView = view

This does some playground trickery and units up an internet view to view the SVG. Press Command-Choice-Return to present this net view in the assistant editor. Ta-da!

Utilizing Courses

Thus far, you used a mixture of structs (worth varieties) and protocols to implement drawable fashions.

Now, it’s time to play with courses, too. Courses allow you to outline base courses and derived courses. The extra conventional object-oriented strategy to the shapes drawback is to make a Form base class with a draw() technique.

Despite the fact that you gained’t use it now, it’s useful to understand how this is able to work. It will look one thing like this:


And, in code, it might appear to be the next block — that is only for reference, so don’t add it to your playground:

class Form
var strokeWidth = 1
var strokeColor = CSSColor.named(identify: .black)
var fillColor = CSSColor.named(identify: .black)
var origin = (x: Zero.Zero, y: Zero.Zero)
func draw(with context: DrawingContext) fatalError(“not implemented”)

class Circle: Form
override init()
strokeWidth = 5
strokeColor = CSSColor.named(identify: .purple)
fillColor = CSSColor.named(identify: .yellow)
origin = (x: 80.Zero, y: 80.Zero)

var radius = 60.Zero
override func draw(with context: DrawingContext)

class Rectangle: Form
override init()
strokeWidth = 5
strokeColor = CSSColor.named(identify: .teal)
fillColor = CSSColor.named(identify: .aqua)
origin = (x: 110.Zero, y: 10.Zero)

var measurement = (width: 100.Zero, peak: 130.Zero)
override func draw(with context: DrawingContext)

So as to make object-oriented programming safer, Swift launched the override key phrase. It requires that you simply, the programmer, acknowledge if you’re overriding one thing.


Regardless of how widespread this sample is, there are some drawbacks to this object-oriented strategy.

The primary drawback you’ll discover is in the base-class implementation of draw. Form needs to keep away from being misused, so it calls fatalError() to alert derived courses that they want to override this technique. Sadly, this examine occurs at runtime time and not compile time.

Secondly, the Circle and Rectangle courses have to cope with the initialization of the base-class knowledge. Whereas this can be a comparatively straightforward state of affairs, class initialization can turn into a considerably concerned course of in order to assure correctness.

Thirdly, it may be tough to future proof a base class. For instance, suppose you needed to add a drawable Line sort. So as to work together with your present system, it will have to derive from Form, which is slightly little bit of a misnomer.

Furthermore, your Line class wants to initialize the bottom class’s fillColor property, and that doesn’t actually make sense for a line.

Lastly, courses have the reference (shared) semantics that have been mentioned earlier. Whereas Automated Reference Counting (ARC) takes care of issues more often than not, you want to watch out not to introduce reference cycles otherwise you’ll find yourself with reminiscence leaks.

In the event you add the identical form to an array of shapes, you could be stunned if you modify the colour of 1 form to purple and one other one additionally appears to randomly change.

Why Even Use a Class?

Given the above downsides, you may marvel why you’d ever need to use a category.

For starters, they permit you to undertake mature and battle-tested frameworks like Cocoa and Cocoa Contact.

Moreover, courses do have extra essential makes use of. For instance, a big memory-hogging, expensive-to-copy object is an effective candidate for wrapping in a category. Courses can mannequin an id nicely. You could have a state of affairs in which many views are displaying the identical object. If that object is modified, all the views additionally mirror modifications in the mannequin. With a worth sort, synchronizing updates can turn out to be a problem.

Briefly, courses are useful anytime reference versus worth semantics come into play.

Take a look at this two-part tutorial on the topic: Reference vs. Worth Types in Swift.

Implementing Computed Properties

All named mannequin varieties allow you to create customized setters and getters that don’t essentially correspond to a saved property.

Suppose you need to add a diameter getter and setter to your Circle mannequin. It’s straightforward to implement it in phrases of the prevailing radius property.

Add the next code to the top of your playground:

extension Circle
var diameter: Double
return radius * 2

radius = newValue / 2

This implements a brand new computed property that’s purely based mostly on the radius. If you get the diameter, it returns the radius doubled. If you set the diameter, it units the radius to the worth divided by two. Easy!

Most of the time, you solely need to implement a particular getter. On this case, you don’t have to embrace the get key phrase block and can simply specify the physique. Perimeter and space are good use instances for this.

Add the next to the Circle extension you simply added:

// Instance of getter-only computed properties
var space: Double
return radius * radius * Double.pi

var perimeter: Double
return 2 * radius * Double.pi

In contrast to courses, struct strategies are usually not allowed to modify, or mutate, saved properties by default, however they will in case you declare them as mutating.

For instance, add the next to the Circle extension:

func shift(x: Double, y: Double)
middle.x += x
middle.y += y

This tries to outline a shift() technique on circle, which strikes the circle in area — i.e., it modifications the middle level.

However this generates the next error on the 2 strains, which increment the middle.x and middle.y properties.

// ERROR: Left aspect of mutating operator has immutable sort ‘Double’

This may be fastened by including the mutating key phrase, like so:

mutating func shift(x: Double, y: Double)
middle.x += x
middle.y += y

This tells Swift that it’s OK that your perform mutates the struct.

Retroactive Modeling and Sort Constraining

One of many nice options of Swift is retroactive modeling. It allows you to prolong the conduct of a mannequin sort even in the event you don’t have the supply code for it.

Right here’s a use case: Suppose you’re a consumer of the SVG code and you need to add an space and perimeter to Rectangle identical to Circle.

To see what this all means, add this to your playground:

extension Rectangle
var space: Double
return measurement.width * measurement.peak

var perimeter: Double
return 2 * (measurement.width + measurement.peak)

This provides an extension to add space and perimeter to an present mannequin, and, now, you’ll formalize these strategies into a brand new protocol.

Add this to your playground:

protocol ClosedShape
var space: Double get
var perimeter: Double get

That provides you an official protocol.

Subsequent, you’ll inform Circle and Rectangle to conform to this protocol retroactively by including the next to your playground:

extension Circle: ClosedShape
extension Rectangle: ClosedShape

You may as well outline a perform that, for instance, computes the entire perimeter of an array of fashions (any mixture of structs, enums or courses) that undertake the ClosedShape protocol.

Add the next to the top of the playground:

func totalPerimeter(shapes: [ClosedShape]) -> Double
return shapes.scale back(Zero) $Zero + $1.perimeter

totalPerimeter(shapes: [circle, rectangle])

This makes use of scale back to calculate the sum of perimeters. You’ll be able to study extra about the way it works in An Introduction to Useful Programming.

The place to Go From Right here?

On this tutorial, you discovered about enum, struct and class — the named mannequin kinds of Swift.

All three have key similarities: They supply encapsulation, can have initializer strategies, can have computed properties, can undertake protocols, and might be modeled retroactively.

I hope you’ve got loved this whirlwind tour of the named mannequin varieties in Swift. In the event you’re in search of a problem, think about constructing a extra full model of the SVG rendering library. You’re off to a very good begin!

As all the time, in case you have questions or insights you desire to to share, please use the boards under!