         )
     }
 
-    private init?(colorExpression: String, type: RuntimeType, for node: LayoutNode) {
+    init?(colorExpression: String, type: RuntimeType = RuntimeType(UIColor.self), for node: LayoutNode) {
         func nameToColorAsset(_ name: String) throws -> Any {
             guard let color = try stringToColorAsset(name) else {
                 throw Expression.Error.message("Invalid color name `\(name)`")

                        return
                    }
                    // Attempt to interpret as a color expression
                    guard let parsedExpression = try? parseExpression(name) else {
                        throw Expression.Error.message("Invalid color name `\(name)`")
                    }
                    self.init(
                        anyExpression: parsedExpression,
                        type: type,
                        nullable: false,
                        symbols: colorSymbols,
                        lookup: colorLookup,
                        for: node
                    )
                case let .expression(parsedExpression):
                    guard let anyExpression = LayoutExpression(
                        anyExpression: parsedExpression,
                        type: RuntimeType(Any.self),
                        nullable: false,
                        symbols: colorSymbols,
                        lookup: colorLookup,
                        for: node
                    ) else {
                        return nil
                    }
                    self.init(
                        evaluate: {
                            switch try unwrap(anyExpression.evaluate()) {
                            case let name as String:
                                return try nameToColorAsset(name)
                            case let color:
                                return try cast(color, as: type)
                            }
                        },
                        symbols: []
                    )
                case .comment:
                    return nil
                }
            } else if #available(iOS 11.0, *) {
                guard let nameExpression = LayoutExpression(stringExpression: colorExpression, for: node) else {
                    return nil
                }
                self.init(
                    evaluate: {
                        try nameToColorAsset(nameExpression.evaluate() as! String)
                    },
                    symbols: []
                )
            } else {
                throw Expression.Error.message("Named colors are only supported in iOS 11 and above")

        do {
            let parts = try parseStringExpression(colorExpression)
            if parts.count == 1 {
                let parsedExpression: ParsedLayoutExpression
                switch parts[0] {
                case let .string(name):
                    if let color = try stringToColorAsset(name) {
