2

Part 2 of exploring/tasting the Swift language takes a look at dictionaries; process flow controls like loops, if/else and switch/case; functions and sorting.

I hope I can follow this up with part 3, a closer look at class operations.

Edited by vegaseat: color

//
//  main.swift
//  Taste_of_swift2
//
// exploring Apple's Swift language, part 2
// vegaseat   08jun2015    used Swift version 1.2

import Foundation

// dictionary ...

// empty dictionary
var staff_name_pay = [String: Float]()
println(staff_name_pay)                // [:]

// add first key:value pair (here name:pay pair)
// staff_name_pay[key] = value
staff_name_pay["Egon Senf"] = 4503.67
println(staff_name_pay)                // [Egon Senf: 4503.67]

// create a name:age dictionary and start populating it
// name is a string and age is an integer
var person_age:[String: Int] = ["Abby": 24, "Udo": 18, "Joe": 27]
for (name, age) in person_age {
    println((name, age))
}

// removes "Udo" from the dictionary
person_age["Udo"] = nil

println(person_age)   // [Joe: 27, Abby: 24]

// change the value for a given key
person_age.updateValue(22, forKey: "Abby")

println(person_age)   // [Joe: 27, Abby: 22]

// create an array of all the keys
var person_keys = Array(person_age.keys)
println(person_keys)    // [Joe, Abby]

// create an array of all the values
var person_values = Array(person_age.values)
println(person_values)  // [27, 22]

println("---------------------")

// loops ...

// by default k is a constant
// note that k is local to the loop
// 1..<4 implies 1 to less than 4
for k in 1..<4 {
    print(k)      // 123
    //print(k++)  // this would be an error since k is a constant
}

println("\n---------------------")

// 1...4 implies 1 to 4 (inclusive)
for k in 1...4 {
    print(k)      // 1234
}

println("\n---------------------")

for c in "abcd" {
    print(c); print(" ")     // a b c d
}

println("\n---------------------")


// can also use traditional C style for loop
// initialization; condition; increment
// use var k to allow k to be changed
// again k is local to the loop
for var k = 0; k < 4; k++ {
    print(String(k) + " ")    // 0 1 2 3
}

println("\n---------------------")

// there is also a while loop
var count = 1
while count < 15 {
    print(count); print(" ")   // 1 4 7 10 13
    count += 3
}

println("\n---------------------")

// the do/while loop goes through the code lines once before
// checking the conditions
var arr2:[Int] = []
var qq = 1
do {
    arr2.append(qq)
    qq *= 10
    
} while qq <= 10000

println(arr2)  // [1, 10, 100, 1000, 10000]

println("---------------------")

// switch/case ...

var range = 20

switch range {
case 0...9:
    println("ones")
case 10...19:
    println("tens")
case 20...29:
    println("twenties")
default:
    println("out of range")
}

var color = "orange red"

switch color {
case "blue":
    println("You like blue")
case "red":
    println("You like red")
case let x where x.hasSuffix("red"):
    println("You like anything with red in it")
case "green":
    println("You live green")
case "purple", "pink":
    println("Ah, the pink and purple kind")
default:
    println("not used")
}


println("---------------------")

// if/else ...

var tem = 45  // deg F

if tem < 30 {
    println("it's cold")
}
else if tem < 40 {
    println("it's cool")
}
else if tem < 70 {
    println("refreshing")
}
else {
    println("let's go to the beach")
}

println("---------------------")

// functions ...

// a function without parameters
func greeting() {
    println("Hello!")
}

// call the function
greeting()  // Hello!

// a function with one input parameter and no return parameter
// by default an empty tuple () meaning void is returned
// any input parameter names are local to the function
// by default they are constants unless prefixed with var
func greeting2(name: String) {
    println("Hello \(name)!")
}

greeting2("Heidi")  // Hello Heidi!

// a function with 2 input parameters and one return parameter
// notice the -> to indicate return type
func greeting3(first: String, last: String) -> String {
    var s = "Hello \(first) \(last)!"
    return s
}

println(greeting3("Fred", "Ferkel"))  // Hello Fred Ferkel!

// a function with 2 return parameters, a tuple () is used
// as an option the return parameters are named
func getNames() -> (first: String, last: String) {
    return ("Fred", "Ferkel")
}

// returned tuple
let tup = getNames()
// use the names from the functions return parameter via a dot syntax
var friend = "\(tup.first) \(tup.last) is my friend."

println(friend) // Fred Ferkel is my friend.

// you can also use the returned tuple index
println(tup.0)  // Fred
println(tup.1)  // Ferkel

// a function with a default parameter
func greeting4(name: String, greet: String = "Hello") {
    println(greet + " " + name + "!")
}

// use default greet
greeting4("Barnie")  // Hello Barnie!
// or supply greet
greeting4("Barnie", greet: "Good morning")  // Good morning Barnie!

// a function with a variadic parameter (count of numbers varies)
// one variadic parameter allowed, has to be last in parameter list
func meanf(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    // cast numbers.count to Double to avoid integer division
    return total / Double(numbers.count)
}

var mean = meanf(1, 2.5, 3, 4.2, 5)
println(mean)  // 3.14

// create an array of strings
var friends: [String] = ["Frank", "William", "Tom"]

// a closure is a function within a function
// here map() contains an unnamed function {} like this ...
var friends_upper = friends.map({
    (s1: String) -> String in
    return s1.uppercaseString
})

println(friends_upper)  // [FRANK, WILLIAM, TOM]

// this can be shortened to ..
var friends_upper2 = friends.map({
    s1 in s1.uppercaseString
})

println(friends_upper2)  // [FRANK, WILLIAM, TOM]

// closures can be further simplified
// to use {} on one line you need the spaces!
var friends_upper3 = friends.map({ $0.uppercaseString })
// or simply ...
var friends_upper4 = friends.map { $0.uppercaseString }

println(friends_upper3)  // [FRANK, WILLIAM, TOM]
println(friends_upper4)  // [FRANK, WILLIAM, TOM]

// a function using "inout" parameters
// x and y cannot be constants
// x and y are are passed as addresses
func swap(inout x: Int, inout y: Int) {
    var t = x
    x = y
    y = t
    // no "return" needed
}

var x = 3
var y = 7
println("Before swap x = \(x)  y = \(y)")
// pass the addresses of x and y (pass by reference)
swap(&x, &y)
println("After swap  x = \(x)  y = \(y)")


// write a name inside angle brackets to make a generic function
// allows for different types of parameter item
func repeat<ItemType>(item: ItemType, times: Int) -> [ItemType] {
    var result = [ItemType]()
    for i in 0..<times {
        result.append(item)
    }
    return result
}
// implied type is string (by inference)
println(repeat("knock", 4)) // [knock, knock, knock, knock]
// implied type is float/double
println(repeat(12.99, 4))   // [12.99, 12.99, 12.99, 12.99]
// or specify type this way
var big: Int64 = 123456789
println(repeat(big, 3))   // [123456789, 123456789, 123456789]

println("---------------------")

// sorting ...

// helper functions for sorted()
func decending(s1: String, s2: String) -> Bool {
    return s1 > s2
}

func ascending(s1: String, s2: String) -> Bool {
    return s1 < s2
}

var names: [String] = ["Karl", "Norman", "Bill", "Larry"]

// apply helper function references to function sorted()
println(sorted(names, ascending))  // [Bill, Karl, Larry, Norman]
println(sorted(names, decending))  // [Norman, Larry, Karl, Bill]

var names2: [String] = ["Zoey", "Tom", "Abby"]

// apply simplified closure function to function sorted()
// compares two parameters $0 and $1
println(sorted(names2, { $0 < $1 }))  // [Abby, Tom, Zoey]
println(sorted(names2, { $0 > $1 }))  // [Zoey, Tom, Abby]

// apply to inplace sort() function (use > for decending sort)
names2.sort { $0 < $1 }
println(names2)          // [Abby, Tom, Zoey]

// really short syntax via an operator function
// Swift infers that the operator compares 2 values
names2.sort( > )
println(names2)          // [Zoey, Tom, Abby]
5
Contributors
23
Replies
94
Views
2 Years
Discussion Span
Last Post by Lardmeister
0

Nice. But it feels like:"Been there, done that..". Change some syntax and some extras, 'et voilĂ ' a new language is born.

0

At first glance Swift looks like another boring curly brace language without the pesky/redundant semicolons. It does have some modern features. Swift is used by Apple developers for the development of OS X and iOS apps.

I like that long lists of often confusing imports and header files are avoided. C, C++, Objective-C and Swift are part of Apple's Xcode development tool. I use the Xcode IDE on my fancy Mac and more or less accidentally bumped into Swift. It looks like Apple plans to make Swift open source for Linux soon. It needs more work to compete with MS Studio languages, Python and Google's Go.

Note that Swift version 2 is out in beta and has made a number of positive changes to the syntax and added improved error handling.

Edited by vegaseat: Swift2

0

Swift was made to replace Objective C used with Apple's Cocoa GUI toolkit for apps, including touch sensitive apps. Apple's free Xcode IDE makes building GUI applications with Cocoa fairly easy with its drag and drop approach.

Note: Objective C is quite an ugly bear.

Edited by vegaseat

0

Apple's Xcode IDE gives you access to the playground where you can test out short segments of Swift code and see the results as you type.

Similar to the Python shell or iPython Notebook.

Even if you don't have an Apple computer, you can enjoy the fun of using the Swift computer language. Just go onto the Swift online playground at swiftstub.com and start typing Swift code!

Edited by vegaseat

1

Some experiments in the Swift playground ...

    String(255, radix: 2)              // "11111111"
    String(255, radix: 16)             // "ff"
    String(format:"hex 255 = %X", 255) // "hex 255 = FF"
    var binValue = 0b0011              // 3
    var hexValue = 0xff                // 255
    String(0xff, radix: 10)            // 255
    0b0100                             // 4
    0b0100 << 2                        // 16
    sqrt(3.14)                         // 1.772004514666935

    // cmd click on sqrt to get list of math functions
    // option click on any object name for declaration info

A note of caution:
Don't have two playgrounds running at the same time, your Apple computer is likely to freeze up!

Edited by vegaseat: playground freeze

1

One more function example tested on the Swift playground ...

// recursive function ...
// n changes so use var n
func factorial(var n: Int) -> Int {
    // use the very handy ternary expression "? :"
    // if n == 0 then 1 "exit condition"
    // else n * factorial(n - 1) "recurse with lower n"
    return n == 0 ? 1 : n * factorial(n - 1)
}

println("factorial(5) = \(factorial(5))")   // factorial(5) = 120
1
// Python-like console user input
func input(prompt: String) -> String {
    print(prompt)
    var keyboard = NSFileHandle.fileHandleWithStandardInput()
    var dataIn = keyboard.availableData
    // convert to a String, use ! to remove option()
    var str = String(NSString(data: dataIn, encoding: NSUTF8StringEncoding)!)
    // remove trailing newline char from string
    str.removeAtIndex(str.endIndex.predecessor())
    return str
}

var name = input("Please enter your name: ")
println("Hello \(name), nice name!")
0

Swift was made to replace Objective C
Is this true? Is Apple going to drop the Objective C monster?

1

I am just learning Swift on my new Mac computer. Coming from a C/C++/Python background, Swift is manageable. If I would be forced to use Objective C, I would have dumped the whole thing. I am sure that some of the Apple engineers were experiencing nausea too, so they started developing Swift. Apple seems to stand behind that effort.

There are plans to make Swift Open Source and port it to Linux too.

Edited by vegaseat

1

Yes, exactly. Objective c is what has driven me to Windows and C#. Perhaps(like it was in the previous century) my next thing will again be a Mac and Swift.

1
// use enumerator to give switch/case a more readable syntax
enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

var myPlanet = Planet.Earth
// change it
myPlanet = .Venus

switch myPlanet {
case .Earth:
    println("You live on Earth")
case .Mars:
    println("You live on Mars")
case .Venus:
    println("You live on Venus")
default:
    println("You live nowhere")
}

Edited by vegaseat: numeric

1

Apple is going in the right direction with Swift. Now they have to work improving the Cocoa GUI toolkit and the UIKit for iOS.

Edited by vegaseat

1
var mixed: [Any] = [12, 12.34, "Frank", (4, 7)]

// use "as" operator to allow for different types in switch/case
for mix in mixed {
    switch mix {
    case let someInt as Int:
        println("integer = \(someInt)") // integer = 12
    case let someDouble as Double:
        println("double = \(someDouble)") // double = 12.34
    case let someString as String:
        println("string = \"\(someString)\"") // string = "Frank"
    case let (x, y) as (Int, Int):
        println("(x, y) point = (\(x), \(y))") // (x, y) point = (4, 7)
    default:
        println("something else")    }
}
1
// create a random integer in a range from low to high (inclusive)
// # forces low: and high: use in function call
func randomIntRange(#low: Int, #high: Int) -> Int {
    let range = high - (low - 1)
    return (Int(arc4random()) % range) + low
}

var arr = [Int]()
for k in 1...5 {
    var rn = randomIntRange(low: 5, high: 10)
    println(rn)
    arr.append(rn)
}
println(arr)  // eg. [10, 9, 6, 5, 9]
1
// create an empty dictionary of [strKey:intArray]
var mydict2 = [String: [Int]]()

// load the first key
mydict2["key1"] = [1, 2, 3]
// append to array in key1
mydict2["key1"]!.append(4)
// show contents
println(mydict2)  // [key1: [1, 2, 3, 4]]
// or ...
mydict2["key1"]! += [5]
// show contents
println(mydict2)  // [key1: [1, 2, 3, 4, 5]]

mydict2["key1"]! += [6, 7]
// show contents
println(mydict2)  // [key1: [1, 2, 3, 4, 5, 6, 7]]
0
// create an array of strings
var friends = ["Frank", "William", "Tom"]

// a closure is a function within a function
// here map() contains an unnamed function {}
// similar to lambda in Python
var friendsUpper = friends.map({
    // receives a string and returns a string
    (s1: String) -> String in
    return s1.uppercaseString
})

println(friendsUpper)  // [FRANK, WILLIAM, TOM]

// shorterhand closure version ...
var friendsUpper2 = friends.map() {$0.uppercaseString}

println(friendsUpper2)  // [FRANK, WILLIAM, TOM]
0

An interesting application of switch/case ...

// is a character upper case?
func isUpper(c: Character) -> Bool {
    switch c {
        case "A"..."Z": return true
        default: return false
    }
}

var ms = "Hello"
// get first character
var fc = Array(ms)[0]
println(isUpper(fc))  // true
0

A little math ...

// get the nth Fibonacci number in the series
func nthFiboBinet(n: Double) -> Int {
    // approximation using Binet's formula'
    // accuracy suffers above n = 70
    let Phi = 1.6180339887498948
    return Int(round(pow(Phi, n)/sqrt(5)))
}

println(nthFiboBinet(0))   // 0
println(nthFiboBinet(15))  // 610

// the 70th fibo should be    190392490709135
println(nthFiboBinet(70))  // 190392490709135  (still OK)

// the 71st fibo should be    308061521170129
println(nthFiboBinet(71))  // 308061521170130

// the 75th fibo should be    2111485077978050
println(nthFiboBinet(75))  // 2111485077978055

Phi is also called the Golden Ratio, the positive solution of
x*x - x - 1 = 0

Edited by vegaseat

0

A little more math ...

// create an array of prime numbers from 2 to < limit
// using a sieve algorithm
func primeArray(limit: Int) -> [Int] {
    // 0 and 1 are not primes
    var boolArr: [Bool] = [false, false]
    // rest of array is set to all true
    for k in 1...limit-2 {
        boolArr.append(true)
    }
    let rangeLimit = Int(sqrt(Double(limit)) + 1.5)
    for var n = 0; n < rangeLimit; n++ {
        if boolArr[n] {
            var square = n*n
            while square < limit {
                // these indeces will not be primes
                boolArr[square] = false
                square += n
            }
        }
    }
    var primes = [Int]()
    // each index of a remaining true is a prime
    for (ix, bool) in enumerate(boolArr) {
        if bool {
            primes.append(ix)
        }
    }
    return primes
}

var primes = primeArray(61)
// first line has known primes for comparison ...
// [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
// [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
println(primes)
0

Coming in the fall of 2015 ...
Swift2 replaces println() with just print() that has a newline default. The sort of thing that Python3 did to print(). There are some other syntax changes.
Good news, there will be a Swift 1-to-2 migrator utility to change Swift1 syntax to Swift2 syntax.

0

someone mentioned that swift will be open source, does that mean we will be able to get the apple OS for free too

0

Apple OSX only runs on Macintoshes, and comes as standard with every Mac, so you never need to buy it. All the upgrades are also free (at least for now).

Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.