How to use ClassWithStaticProperty class

1//
2//  ImplicitVariableTypes.swift
3//  MockingbirdTestsHost
4//
5//  Created by Andrew Chang on 5/4/20.
6//
7
8import Foundation
9
10func NotAType() -> Bool { return true }
11
12enum EnumWithCapitalizedCases {
13  case Success
14  case Failure
15}
16
17enum EnumWithAssociatedValues {
18  case success(message: String)
19  case failure(message: String)
20}
21
22class ClassWithProperty {
23  var property: String { fatalError() }
24}
25
26class ClassWithStaticProperty {
27  static var property: String { fatalError() }
28}
29
30class ImplicitVariableTypes {
31  // MARK: Inferrable
32  var boolType = true
33  var tupleType = (true, true)
34  var stringType = "foo"
35  var intType = 42
36  var doubleType = 42.0
37  var stringArrayType = ["foo", "bar"]
38  var dictionaryType = ["foo": true, "bar": false]
39  var dictionaryArrayType = ["foo": [true, true], "bar": [false, false]]
40  var dictionaryDictionaryType = ["foo": ["hello": true], "bar": ["world": false]]
41  var qualifiedEnumType = EnumType.success
42  var explicitInitializedType = String.init("a")
43  var implicitInitializedType = Bool(booleanLiteral: true)
44  var implicitGenericInitializedType = Array<(String, Int)>(arrayLiteral: ("foo", 1))
45  var qualifiedImplicitInitializedType = Swift.Bool(booleanLiteral: true)
46  
47  // MARK: Not inferrable
48  var complexFunctionalType = "foo".map({ $0.uppercased() })
49  var qualifiedCapitalizedEnumType = EnumWithCapitalizedCases.Success
50  var qualifiedAssociatedValueEnumType = EnumWithAssociatedValues.success(message: "foo")
51  var classWithProperty = ClassWithProperty().property
52  lazy var lazyComplexFunctionalType = self.stringType.map({ $0.uppercased() })
53  
54  // TODO: Edge cases the type inference system doesn't handle yet.
55  // var classWithStaticProperty = ClassWithStaticProperty.property
56  // var actuallyAFunction = NotAType()
57}
58

Source: ImplicitVariableTypes.swift

//
//  ImplicitVariableTypes.swift
//  MockingbirdTestsHost
//
//  Created by Andrew Chang on 5/4/20.
//

import Foundation

func NotAType() -> Bool { return true }

enum EnumWithCapitalizedCases {
  case Success
  case Failure
}

enum EnumWithAssociatedValues {
  case success(message: String)
  case failure(message: String)
}

class ClassWithProperty {
  var property: String { fatalError() }
}

class ClassWithStaticProperty {
  static var property: String { fatalError() }
}

class ImplicitVariableTypes {
  // MARK: Inferrable
  var boolType = true
  var tupleType = (true, true)
  var stringType = "foo"
  var intType = 42
  var doubleType = 42.0
  var stringArrayType = ["foo", "bar"]
  var dictionaryType = ["foo": true, "bar": false]
  var dictionaryArrayType = ["foo": [true, true], "bar": [false, false]]
  var dictionaryDictionaryType = ["foo": ["hello": true], "bar": ["world": false]]
  var qualifiedEnumType = EnumType.success
  var explicitInitializedType = String.init("a")
  var implicitInitializedType = Bool(booleanLiteral: true)
  var implicitGenericInitializedType = Array<(String, Int)>(arrayLiteral: ("foo", 1))
  var qualifiedImplicitInitializedType = Swift.Bool(booleanLiteral: true)
  
  // MARK: Not inferrable
  var complexFunctionalType = "foo".map({ $0.uppercased() })
  var qualifiedCapitalizedEnumType = EnumWithCapitalizedCases.Success
  var qualifiedAssociatedValueEnumType = EnumWithAssociatedValues.success(message: "foo")
  var classWithProperty = ClassWithProperty().property
  lazy var lazyComplexFunctionalType = self.stringType.map({ $0.uppercased() })
  
  // TODO: Edge cases the type inference system doesn't handle yet.
  // var classWithStaticProperty = ClassWithStaticProperty.property
  // var actuallyAFunction = NotAType()
}