How to use render method of ThunkTemplate class

...41    let getterDefinition = PropertyDefinitionTemplate(42      type: .getter,43      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :44        ThunkTemplate(mockableType: context.mockableType,45                      invocation: getterInvocation.render(),46                      shortSignature: method.parameters.isEmpty ? nil : shortSignature,47                      longSignature: longSignature,48                      returnType: matchableReturnType,49                      isBridged: true,50                      isThrowing: method.isThrowing,51                      isStatic: method.kind.typeScope.isStatic,52                      callMember: { scope in53                        return "\(scope)[\(separated: callArguments)]"54                      },55                      invocationArguments: invocationArguments).render())56    57    let setterShortSignature = method.parameters.isEmpty ? nil : """58    ()\(method.isThrowing ? " throws" : "") -> Void59    """60    let setterParameterTypes = matchableParameterTypes + [matchableReturnType]61    let setterLongSignature = """62    (\(separated: setterParameterTypes))\(method.isThrowing ? " throws" : "") -> Void63    """64    let setterInvocationArguments = invocationArguments + [(nil, "newValue")]65    let setterDefinition = PropertyDefinitionTemplate(66      type: .setter,67      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :68        ThunkTemplate(mockableType: context.mockableType,69                      invocation: setterInvocation.render(),70                      shortSignature: setterShortSignature,71                      longSignature: setterLongSignature,72                      returnType: "Void",73                      isBridged: true,74                      isThrowing: method.isThrowing,75                      isStatic: method.kind.typeScope.isStatic,76                      callMember: { scope in77                        return "\(scope)[\(separated: callArguments)] = newValue"78                      },79                      invocationArguments: setterInvocationArguments).render())80    81    return String(lines: [82      "// MARK: Mocked \(fullNameForMocking)",83      VariableDefinitionTemplate(attributes: method.attributes.safeDeclarations,84                                 declaration: "public \(overridableModifiers)\(uniqueDeclaration)",85                                 body: String(lines: [getterDefinition.render(),86                                                      setterDefinition.render()])).render(),87    ])88  }89  90  override var synthesizedDeclarations: String {91    let getterReturnType = matchableReturnType92    let setterReturnType = "Void"93    94    let modifiers = method.isThrowing ? " throws" : ""95    96    let getterInvocationType = """97    (\(separated: matchableParameterTypes))\(modifiers) -> \(getterReturnType)98    """99    100    let setterParameterTypes = matchableParameterTypes + [matchableReturnType]101    let setterInvocationType = """102    (\(separated: setterParameterTypes))\(modifiers) -> \(setterReturnType)103    """104    105    var mockableMethods = [String]()106    107    let getterGenericTypes = ["\(Declaration.subscriptGetterDeclaration)",108                              getterInvocationType,109                              getterReturnType]110    let setterGenericTypes = ["\(Declaration.subscriptSetterDeclaration)",111                              setterInvocationType,112                              setterReturnType]113    114    mockableMethods.append(matchableSubscript(isGetter: true,115                                              genericTypes: getterGenericTypes))116    mockableMethods.append(matchableSubscript(isGetter: false,117                                              genericTypes: setterGenericTypes))118    119    if method.isVariadic {120      // Allow methods with a variadic parameter to use variadics when stubbing.121      mockableMethods.append(matchableSubscript(isGetter: true,122                                                isVariadic: true,123                                                genericTypes: getterGenericTypes))124      mockableMethods.append(matchableSubscript(isGetter: false,125                                                isVariadic: true,126                                                genericTypes: setterGenericTypes))127    }128    129    return String(lines: mockableMethods, spacing: 2)130  }131  132  func matchableSubscript(isGetter: Bool,133                          isVariadic: Bool = false,134                          genericTypes: [String]) -> String {135    let variant: FunctionVariant = isGetter ? .subscriptGetter : .subscriptSetter136    let name = fullName(for: .matching(useVariadics: isVariadic, variant: variant))137    let namePrefix = isGetter ? "get" : "set"138    let returnType = isGetter ? "\(parenthetical: matchableReturnType)" : "Void"139    let selectorName = isGetter ?140      uniqueDeclarationForSubscriptGetter : uniqueDeclarationForSubscriptSetter141    142    let argumentMatchers: String143    if isVariadic {144      argumentMatchers = isGetter ?145        resolvedVariadicArgumentMatchers : resolvedVariadicArgumentMatchersForSubscriptSetter146    } else {147      argumentMatchers = isGetter ?148        resolvedArgumentMatchers : resolvedArgumentMatchersForSubscriptSetter149    }150    151    let invocation = ObjectInitializationTemplate(152      name: "Mockingbird.SwiftInvocation",153      arguments: [154        ("selectorName", "\(doubleQuoted: selectorName)"),155        ("setterSelectorName", "\(doubleQuoted: uniqueDeclarationForSubscriptSetter)"),156        ("selectorType", "Mockingbird.SelectorType.subscript" + (isGetter ? "Getter" : "Setter")),157        ("arguments", "[\(argumentMatchers)]"),158        ("returnType", "Swift.ObjectIdentifier(\(returnType).self)"),159      ])160    161    let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """162    return \(ObjectInitializationTemplate(163      name: "Mockingbird.Mockable",164      genericTypes: genericTypes,165              arguments: [("mock", mockObject), ("invocation", invocation.render())]))166    """167    168    let syntheizedReturnType = "Mockingbird.Mockable<\(separated: genericTypes)>"169    let declaration = "public \(regularModifiers)func \(namePrefix)\(name.capitalizedFirst) -> \(syntheizedReturnType)"170    let genericConstraints = method.whereClauses.map({ context.specializeTypeName("\($0)") })171    return FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,172                                      declaration: declaration,173                                      genericConstraints: genericConstraints,174                                      body: body).render()175  }176  177  lazy var uniqueDeclarationForSubscriptGetter: String = {178    let fullName = self.fullName(for: .mocking(variant: .subscriptGetter))179    return "get.\(fullName)\(returnTypeAttributesForMocking) -> \(mockableReturnType)\(genericConstraints)"180  }()181  182  lazy var uniqueDeclarationForSubscriptSetter: String = {183    let fullName = self.fullName(for: .mocking(variant: .subscriptSetter))184    return "set.\(fullName)\(returnTypeAttributesForMocking) -> \(mockableReturnType)\(genericConstraints)"185  }()186  187  lazy var resolvedArgumentMatchersForSubscriptSetter: String = {188    let parameters = method.parameters.map({ ($0.name, true) }) + [("newValue", true)]...

...15    self.variable = variable16    self.context = context17  }18  19  func render() -> String {20    let (directiveStart, directiveEnd) = compilationDirectiveDeclaration21    return String(lines: [directiveStart,22                          String(lines: [mockedDeclaration, synthesizedDeclarations], spacing: 2),23                          directiveEnd])24  }25  26  var compilationDirectiveDeclaration: (start: String, end: String) {27    guard !variable.compilationDirectives.isEmpty else { return ("", "") }28    let start = String(lines: variable.compilationDirectives.map({ $0.declaration }))29    let end = String(lines: variable.compilationDirectives.map({ _ in "#endif" }))30    return (start, end)31  }32  33  lazy var getterInvocation: String = {34    return ObjectInitializationTemplate(35      name: "Mockingbird.SwiftInvocation",36      arguments: [37        ("selectorName", "\(doubleQuoted: getterName)"),38        ("setterSelectorName", "\(doubleQuoted: setterName)"),39        ("selectorType", "Mockingbird.SelectorType.getter"),40        ("arguments", "[]"),41        ("returnType", "Swift.ObjectIdentifier(\(parenthetical: matchableType).self)"),42      ]).render()43  }()44  45  lazy var mockableSetterInvocation: String = {46    return ObjectInitializationTemplate(47      name: "Mockingbird.SwiftInvocation",48      arguments: [49        ("selectorName", "\(doubleQuoted: setterName)"),50        ("setterSelectorName", "\(doubleQuoted: setterName)"),51        ("selectorType", "Mockingbird.SelectorType.setter"),52        ("arguments", "[Mockingbird.ArgumentMatcher(newValue)]"),53        ("returnType", "Swift.ObjectIdentifier(Void.self)"),54      ]).render()55  }()56  57  lazy var matchableSetterInvocation: String = {58    return ObjectInitializationTemplate(59      name: "Mockingbird.SwiftInvocation",60      arguments: [61        ("selectorName", "\(doubleQuoted: setterName)"),62        ("setterSelectorName", "\(doubleQuoted: setterName)"),63        ("selectorType", "Mockingbird.SelectorType.setter"),64        ("arguments", "[Mockingbird.resolve(newValue)]"),65        ("returnType", "Swift.ObjectIdentifier(Void.self)"),66      ]).render()67  }()68  69  var mockedDeclaration: String {70    let getterDefinition = PropertyDefinitionTemplate(71      type: .getter,72      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :73        ThunkTemplate(mockableType: context.mockableType,74                      invocation: getterInvocation,75                      shortSignature: nil,76                      longSignature: "() -> \(matchableType)",77                      returnType: matchableType,78                      isBridged: true,79                      isThrowing: false,80                      isStatic: variable.kind.typeScope.isStatic,81                      callMember: { scope in82                        return "\(scope).\(backticked: self.variable.name)"83                      },84                      invocationArguments: []).render())85    let setterDefinition = PropertyDefinitionTemplate(86      type: .setter,87      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :88        ThunkTemplate(mockableType: context.mockableType,89                      invocation: mockableSetterInvocation,90                      shortSignature: "() -> Void",91                      longSignature: "\(parenthetical: matchableType) -> Void",92                      returnType: "Void",93                      isBridged: true,94                      isThrowing: false,95                      isStatic: variable.kind.typeScope.isStatic,96                      callMember: { scope in97                        return "\(scope).\(backticked: self.variable.name) = newValue"98                      },99                      invocationArguments: [(nil, "newValue")]).render())100  101    let accessors = !shouldGenerateSetter ? [getterDefinition.render()] : [102      getterDefinition.render(),103      setterDefinition.render(),104    ]105    106    let override = variable.isOverridable ? "override " : ""107    let declaration = "\(override)public \(modifiers)var \(backticked: variable.name): \(mockableType)"108    return String(lines: [109      "// MARK: Mocked \(variable.name)",110      VariableDefinitionTemplate(attributes: variable.attributes.safeDeclarations,111                                 declaration: declaration,112                                 body: String(lines: accessors)).render()113    ])114  }115  116  var synthesizedDeclarations: String {117    let getterGenericTypes = ["\(Declaration.propertyGetterDeclaration)",118                              "() -> \(matchableType)",119                              matchableType]120    let setterGenericTypes = ["\(Declaration.propertySetterDeclaration)",121                              "(\(matchableType)) -> Void",122                              "Void"]123    124    let getterReturnType = "Mockingbird.Mockable<\(separated: getterGenericTypes)>"125    let getterDefinition = FunctionDefinitionTemplate(126      attributes: variable.attributes.safeDeclarations,127      declaration: "public \(modifiers)func get\(capitalizedName)() -> \(getterReturnType)",128      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """129      return \(ObjectInitializationTemplate(130                name: "Mockingbird.Mockable",131                genericTypes: getterGenericTypes,132                arguments: [("mock", mockObject), ("invocation", getterInvocation)]))133      """)134    135    let setterReturnType = "Mockingbird.Mockable<\(separated: setterGenericTypes)>"136    let setterDefinition = FunctionDefinitionTemplate(137      attributes: variable.attributes.safeDeclarations,138      declaration: "public \(modifiers)func set\(capitalizedName)(_ newValue: @autoclosure () -> \(matchableType)) -> \(setterReturnType)",139      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """140      return \(ObjectInitializationTemplate(141                name: "Mockingbird.Mockable",142                genericTypes: setterGenericTypes,143                arguments: [("mock", mockObject), ("invocation", matchableSetterInvocation)]))144      """)145    146    let accessors = !shouldGenerateSetter ? [getterDefinition.render()] : [147      getterDefinition.render(),148      setterDefinition.render(),149    ]150    return String(lines: accessors, spacing: 2)151  }152  153  lazy var modifiers: String = {154    return variable.kind.typeScope.isStatic ? "class " : ""155  }()156  157  lazy var mockObject: String = {158    return variable.kind.typeScope.isStatic ? "staticMock" : "self"159  }()160  161  // Keep this in sync with `MockingbirdFramework.Invocation.Constants.getterSuffix`162  lazy var getterName: String = {...

...49    self.callMember = callMember50    self.invocationArguments = invocationArguments51  }52  53  func render() -> String {54    let unlabledArguments = invocationArguments.map({ $0.parameterName })55    let callDefault = IfStatementTemplate(56      condition: "let mkbImpl = mkbImpl as? \(longSignature)",57      body: """58      return \(FunctionCallTemplate(name: "mkbImpl",59                                    unlabeledArguments: unlabledArguments,60                                    isThrowing: isThrowing))61      """)62    let callConvenience: String = {63      guard let shortSignature = shortSignature else { return "" }64      return IfStatementTemplate(65        condition: "let mkbImpl = mkbImpl as? \(shortSignature)",66        body: """67        return \(FunctionCallTemplate(name: "mkbImpl", isThrowing: isThrowing))68        """).render()69    }()70    71    let callBridgedDefault: String = {72      guard isBridged else { return "" }73      let bridgedSignature = """74      (\(String(list: Array(repeating: "Any?", count: unlabledArguments.count)))) -> Any?75      """76      return IfStatementTemplate(77        condition: "let mkbImpl = mkbImpl as? \(bridgedSignature)",78        body: """79        return \(FunctionCallTemplate(80                  name: "Mockingbird.dynamicCast",81                  unlabeledArguments: [82                    FunctionCallTemplate(83                      name: "mkbImpl",84                      unlabeledArguments: unlabledArguments,85                      isThrowing: isThrowing).render()86                  ])) as \(returnType)87        """).render()88    }()89    let callBridgedConvenience: String = {90      guard isBridged else { return "" }91      return IfStatementTemplate(92        condition: "let mkbImpl = mkbImpl as? () -> Any?",93        body: """94        return \(FunctionCallTemplate(95                  name: "Mockingbird.dynamicCast",96                  unlabeledArguments: [97                    FunctionCallTemplate(name: "mkbImpl", isThrowing: isThrowing).render()98                  ])) as \(returnType)99        """).render()100    }()101    102    let context = isStatic ? "self.staticMock.mockingbirdContext" : "self.mockingbirdContext"103    let supertype = isStatic ? "MockingbirdSupertype.Type" : "MockingbirdSupertype"104    let didInvoke = FunctionCallTemplate(name: "\(context).mocking.didInvoke",105                                         unlabeledArguments: [invocation],106                                         isThrowing: isThrowing)107    108    let isSubclass = mockableType.kind != .class109    110    // TODO: Handle generic protocols111    let isGeneric = !mockableType.genericTypes.isEmpty || mockableType.hasSelfConstraint112    let isProxyable = !(mockableType.kind == .protocol && isGeneric)113    114    return """115    return \(didInvoke) \(BlockTemplate(body: """116    \(FunctionCallTemplate(name: "\(context).recordInvocation", arguments: [(nil, "$0")]))117    let mkbImpl = \(FunctionCallTemplate(name: "\(context).stubbing.implementation",118                                         arguments: [("for", "$0")]))119    \(String(lines: [120      callDefault.render(),121      callConvenience,122      callBridgedDefault,123      callBridgedConvenience,124      !isSubclass && !isProxyable ? "" : ForInStatementTemplate(125        item: "mkbTargetBox",126        collection: "\(context).proxy.targets(for: $0)",127        body: SwitchStatementTemplate(128          controlExpression: "mkbTargetBox.target",129          cases: [130            (".super", isSubclass ? "break" : "return \(callMember(.super))"),131            (".object" + (isProxyable ? "(let mkbObject)" : ""), !isProxyable ? "break" : """132            \(GuardStatementTemplate(133                condition: "var mkbObject = mkbObject as? \(supertype)", body: "break"))134            let mkbValue: \(returnType) = \(callMember(.object))135            \(FunctionCallTemplate(136                name: "\(context).proxy.updateTarget",137                arguments: [(nil, "&mkbObject"), ("in", "mkbTargetBox")]))138            return mkbValue139            """)140          ]).render()).render(),141    ]))142    \(IfStatementTemplate(143        condition: """144        let mkbValue = \(FunctionCallTemplate(145                          name: "\(context).stubbing.defaultValueProvider.value.provideValue",146                          arguments: [("for", "\(parenthetical: returnType).self")]))147        """,148        body: "return mkbValue"))149    \(FunctionCallTemplate(name: "\(context).stubbing.failTest",150                           arguments: [151                            ("for", "$0"),152                            ("at", "\(context).sourceLocation")]).render())153    """))154    """155  }156}...

1let thunk = ThunkTemplate()2thunk.render()3let thunk = ThunkTemplate()4thunk.render()5let thunk = ThunkTemplate()6thunk.render()7let thunk = ThunkTemplate()8thunk.render()9let thunk = ThunkTemplate()10thunk.render()11let thunk = ThunkTemplate()12thunk.render()13let thunk = ThunkTemplate()14thunk.render()15let thunk = ThunkTemplate()16thunk.render()17let thunk = ThunkTemplate()18thunk.render()19let thunk = ThunkTemplate()20thunk.render()21let thunk = ThunkTemplate()22thunk.render()23let thunk = ThunkTemplate()24thunk.render()25let thunk = ThunkTemplate()26thunk.render()27let thunk = ThunkTemplate()28thunk.render()29let thunk = ThunkTemplate()30thunk.render()31let thunk = ThunkTemplate()32thunk.render()33let thunk = ThunkTemplate()34thunk.render()

1import ThunkTemplate2let thunk = ThunkTemplate()3thunk.render()4import ThunkTemplate5let thunk = ThunkTemplate()6thunk.render()7import ThunkTemplate8let thunk = ThunkTemplate()9thunk.render()10import ThunkTemplate11let thunk = ThunkTemplate()12thunk.render()13import ThunkTemplate14let thunk = ThunkTemplate()15thunk.render()16import ThunkTemplate17let thunk = ThunkTemplate()18thunk.render()19import ThunkTemplate20let thunk = ThunkTemplate()21thunk.render()22import ThunkTemplate23let thunk = ThunkTemplate()24thunk.render()25import ThunkTemplate26let thunk = ThunkTemplate()27thunk.render()28import ThunkTemplate29let thunk = ThunkTemplate()30thunk.render()31import ThunkTemplate32let thunk = ThunkTemplate()33thunk.render()34import ThunkTemplate35let thunk = ThunkTemplate()36thunk.render()37import ThunkTemplate38let thunk = ThunkTemplate()39thunk.render()40import ThunkTemplate41let thunk = ThunkTemplate()42thunk.render()43import ThunkTemplate

1import UIKit2import Thunk3class ViewController: UIViewController {4    override func viewDidLoad() {5        super.viewDidLoad()6        let thunkTemplate = ThunkTemplate()7        thunkTemplate.render(view: self.view)8    }9    override func didReceiveMemoryWarning() {10        super.didReceiveMemoryWarning()11    }12}13import UIKit14class ThunkTemplate: NSObject {15    func render(view: UIView) {16    }17}18import UIKit19class ThunkTemplate: NSObject {20    func render(view: UIView) {21    }22}23import UIKit24class ThunkTemplate: NSObject {25    func render(view: UIView) {26    }27}28import UIKit29class ThunkTemplate: NSObject {30    func render(view: UIView) {31    }32}33import UIKit34class ThunkTemplate: NSObject {35    func render(view: UIView) {36    }37}38import UIKit39class ThunkTemplate: NSObject {40    func render(view: UIView) {41    }42}43import UIKit44class ThunkTemplate: NSObject {45    func render(view: UIView) {46    }47}48import UIKit49class ThunkTemplate: NSObject {50    func render(view: UIView) {51    }52}53import UIKit54class ThunkTemplate: NSObject {55    func render(view: UIView) {56    }57}58import UIKit

1import UIKit2class ViewController: UIViewController {3    override func viewDidLoad() {4        super.viewDidLoad()5        let thunkTemplate = ThunkTemplate()6        thunkTemplate.render()7    }8    override func didReceiveMemoryWarning() {9        super.didReceiveMemoryWarning()10    }11}12import UIKit13class ThunkTemplate: NSObject {14    func render() {15        print("ThunkTemplate")16    }17}18import UIKit19class ThunkTemplate: NSObject {20    func render() {21        print("ThunkTemplate")22    }23}24import UIKit25class ThunkTemplate: NSObject {26    func render() {27        print("ThunkTemplate")28    }29}30import UIKit31class ThunkTemplate: NSObject {32    func render() {33        print("ThunkTemplate")34    }35}36import UIKit37class ThunkTemplate: NSObject {38    func render() {39        print("ThunkTemplate")40    }41}42import UIKit43class ThunkTemplate: NSObject {44    func render() {45        print("ThunkTemplate")46    }47}48import UIKit49class ThunkTemplate: NSObject {50    func render() {51        print("ThunkTemplate")52    }53}54import UIKit55class ThunkTemplate: NSObject {56    func render() {57        print("ThunkTemplate")58    }59}60import UIKit61class ThunkTemplate: NSObject {62    func render() {63        print("ThunkTemplate")64    }65}66import UIKit67class ThunkTemplate: NSObject {68    func render() {69        print("ThunkTemplate")70    }71}72import UIKit73class ThunkTemplate: NSObject {74    func render() {75        print("ThunkTemplate")76    }77}

1let template = ThunkTemplate()2let result = template.render()3let template = ThunkTemplate()4let result = template.render()5let template = ThunkTemplate()6let result = template.render()7let template = ThunkTemplate()8let result = template.render()9let template = ThunkTemplate()10let result = template.render()11let template = ThunkTemplate()12let result = template.render()13let template = ThunkTemplate()14let result = template.render()15let template = ThunkTemplate()16let result = template.render()17let template = ThunkTemplate()18let result = template.render()19let template = ThunkTemplate()20let result = template.render()21let template = ThunkTemplate()22let result = template.render()23let template = ThunkTemplate()24let result = template.render()25let template = ThunkTemplate()26let result = template.render()27let template = ThunkTemplate()28let result = template.render()29let template = ThunkTemplate()30let result = template.render()31let template = ThunkTemplate()32let result = template.render()

1import UIKit2class ViewController: UIViewController {3    override func viewDidLoad() {4        super.viewDidLoad()5        let template = ThunkTemplate()6        let view = template.render()7        view.frame = CGRect(x: 0, y: 0, width: 100, height: 100)8        self.view.addSubview(view)9    }

1import Foundation2class ThunkTemplate {3    func render() {4        print("render")5    }6}7import Foundation8class ThunkTemplate {9    func render() {10        print("render")11    }12}13import Foundation14class ThunkTemplate {15    func render() {16        print("render")17    }18}19import Foundation20class ThunkTemplate {21    func render() {22        print("render")23    }24}25import Foundation26class ThunkTemplate {27    func render() {28        print("render")29    }30}31import Foundation32class ThunkTemplate {33    func render() {34        print("render")35    }36}37import Foundation38class ThunkTemplate {39    func render() {40        print("render")41    }42}43import Foundation44class ThunkTemplate {45    func render() {46        print("render")47    }48}49import Foundation50class ThunkTemplate {51    func render() {52        print("render")53    }54}55import Foundation56class ThunkTemplate {57    func render() {58        print("render")

1import Foundation2class ThunkTemplate {3    func render() -> String {4    }5}6let thunkTemplate = ThunkTemplate()7print(thunkTemplate.render())8import Foundation9class ThunkTemplate {10    func render() -> String {11    }12}13let thunkTemplate = ThunkTemplate()14print(thunkTemplate.render())15import Foundation16class ThunkTemplate {17    func render() -> String {18    }19}20let thunkTemplate = ThunkTemplate()21print(thunkTemplate.render())22import Foundation23class ThunkTemplate {24    func render() -> String {25    }26}27let thunkTemplate = ThunkTemplate()28print(thunkTemplate.render())29import Foundation30class ThunkTemplate {31    func render() -> String {32    }33}34let thunkTemplate = ThunkTemplate()35print(thunkTemplate.render())36import Foundation37class ThunkTemplate {38    func render() -> String {39    }40}41let thunkTemplate = ThunkTemplate()42print(thunkTemplate.render())43import Foundation44class ThunkTemplate {45    func render() ->