Swift Package IndexBuild Information
Failed to build Scout, reference 4.1.0 (da48b2), with Swift 6.2 (beta) for Linux on 20 Jun 2025 12:18:15 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-2":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
========================================
RunAll
========================================
Builder version: 4.64.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/ABridoux/scout.git
Reference: 4.1.0
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/ABridoux/scout
* tag 4.1.0 -> FETCH_HEAD
HEAD is now at da48b20 Merge pull request #270 from ABridoux/release/4.1.0
Cloned https://github.com/ABridoux/scout.git
Revision (git rev-parse @):
da48b2086117d13702afc6c731618a0b4245cc11
SUCCESS checkout https://github.com/ABridoux/scout.git at 4.1.0
========================================
Build
========================================
Selected platform: linux
Swift version: 6.2
Building package at path: $PWD
https://github.com/ABridoux/scout.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4606859-2":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.2-latest: Pulling from finestructure/spi-images
Digest: sha256:f81a7bd7aa87a0f81848d48c5bcc03f5f78deebd37fa5f9be9913077205d3687
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.2-latest
Fetching https://github.com/jpsim/Yams.git
Fetching https://github.com/ABridoux/BooleanExpressionEvaluation
Fetching https://github.com/apple/swift-argument-parser
Fetching https://github.com/ABridoux/lux
Fetching https://github.com/apple/swift-docc-plugin
[1/541] Fetching booleanexpressionevaluation
[483/2623] Fetching booleanexpressionevaluation, swift-docc-plugin
[713/4164] Fetching booleanexpressionevaluation, swift-docc-plugin, lux
[903/15023] Fetching booleanexpressionevaluation, swift-docc-plugin, lux, yams
[3555/30403] Fetching booleanexpressionevaluation, swift-docc-plugin, lux, yams, swift-argument-parser
Fetched https://github.com/ABridoux/BooleanExpressionEvaluation from cache (0.68s)
[6151/29862] Fetching swift-docc-plugin, lux, yams, swift-argument-parser
Fetching https://github.com/tadija/AEXML.git
Fetched https://github.com/apple/swift-docc-plugin from cache (0.70s)
[4440/27780] Fetching lux, yams, swift-argument-parser
Fetched https://github.com/ABridoux/lux from cache (0.95s)
[18676/26239] Fetching yams, swift-argument-parser
[21201/28366] Fetching yams, swift-argument-parser, aexml
Fetched https://github.com/tadija/AEXML.git from cache (0.50s)
[22656/26239] Fetching yams, swift-argument-parser
Fetched https://github.com/apple/swift-argument-parser from cache (1.36s)
[8253/10859] Fetching yams
Fetching https://github.com/swiftcsv/SwiftCSV
Fetched https://github.com/jpsim/Yams.git from cache (3.13s)
[1/1780] Fetching swiftcsv
Fetched https://github.com/swiftcsv/SwiftCSV from cache (1.03s)
Computing version for https://github.com/ABridoux/BooleanExpressionEvaluation
Computed https://github.com/ABridoux/BooleanExpressionEvaluation at 2.0.1 (4.62s)
Computing version for https://github.com/tadija/AEXML.git
Computed https://github.com/tadija/AEXML.git at 4.7.0 (0.63s)
Computing version for https://github.com/jpsim/Yams.git
Computed https://github.com/jpsim/Yams.git at 4.0.6 (0.54s)
Computing version for https://github.com/apple/swift-docc-plugin
Computed https://github.com/apple/swift-docc-plugin at 1.4.4 (0.53s)
Fetching https://github.com/swiftlang/swift-docc-symbolkit
[1/3413] Fetching swift-docc-symbolkit
Fetched https://github.com/swiftlang/swift-docc-symbolkit from cache (0.41s)
Computing version for https://github.com/swiftlang/swift-docc-symbolkit
Computed https://github.com/swiftlang/swift-docc-symbolkit at 1.0.0 (1.46s)
Computing version for https://github.com/swiftcsv/SwiftCSV
Computed https://github.com/swiftcsv/SwiftCSV at 0.10.0 (0.54s)
Computing version for https://github.com/ABridoux/lux
Computed https://github.com/ABridoux/lux at 0.5.0 (0.92s)
Fetching https://github.com/scinfu/SwiftSoup.git
Fetching https://github.com/JohnSundell/Splash
[1/2167] Fetching splash
[1583/6083] Fetching splash, swiftsoup
Fetched https://github.com/JohnSundell/Splash from cache (0.52s)
Fetched https://github.com/scinfu/SwiftSoup.git from cache (0.52s)
Computing version for https://github.com/JohnSundell/Splash
Computed https://github.com/JohnSundell/Splash at 0.16.0 (1.41s)
Computing version for https://github.com/scinfu/SwiftSoup.git
Computed https://github.com/scinfu/SwiftSoup.git at 1.7.5 (3.43s)
Computing version for https://github.com/apple/swift-argument-parser
Computed https://github.com/apple/swift-argument-parser at 0.5.0 (0.58s)
Creating working copy for https://github.com/apple/swift-docc-plugin
Working copy of https://github.com/apple/swift-docc-plugin resolved at 1.4.4
Creating working copy for https://github.com/ABridoux/lux
Working copy of https://github.com/ABridoux/lux resolved at 0.5.0
Creating working copy for https://github.com/tadija/AEXML.git
Working copy of https://github.com/tadija/AEXML.git resolved at 4.7.0
Creating working copy for https://github.com/jpsim/Yams.git
Working copy of https://github.com/jpsim/Yams.git resolved at 4.0.6
Creating working copy for https://github.com/JohnSundell/Splash
Working copy of https://github.com/JohnSundell/Splash resolved at 0.16.0
Creating working copy for https://github.com/scinfu/SwiftSoup.git
Working copy of https://github.com/scinfu/SwiftSoup.git resolved at 1.7.5
Creating working copy for https://github.com/swiftlang/swift-docc-symbolkit
Working copy of https://github.com/swiftlang/swift-docc-symbolkit resolved at 1.0.0
Creating working copy for https://github.com/swiftcsv/SwiftCSV
Working copy of https://github.com/swiftcsv/SwiftCSV resolved at 0.10.0
Creating working copy for https://github.com/apple/swift-argument-parser
Working copy of https://github.com/apple/swift-argument-parser resolved at 0.5.0
Creating working copy for https://github.com/ABridoux/BooleanExpressionEvaluation
Working copy of https://github.com/ABridoux/BooleanExpressionEvaluation resolved at 2.0.1
[1/1] Compiling plugin Swift-DocC Preview
[2/2] Compiling plugin Swift-DocC
Building for debugging...
[2/38] Write sources
[2/38] Copying PrivacyInfo.xcprivacy
[2/38] Write sources
[16/38] Compiling writer.c
[17/38] Compiling reader.c
[18/38] Compiling parser.c
[19/38] Compiling api.c
[20/38] Compiling emitter.c
[21/38] Compiling scanner.c
[22/38] Write swift-version-24593BA9C3E375BF.txt
[24/166] Emitting module SwiftCSV
[25/167] Emitting module SwiftSoup
[26/174] Emitting module Yams
[27/175] Compiling SwiftCSV String+Lines.swift
[28/175] Emitting module AEXML
[29/175] Compiling SwiftSoup ArrayExt.swift
[30/175] Compiling SwiftSoup Attribute.swift
[31/175] Compiling SwiftCSV Parser.swift
[32/175] Compiling SwiftCSV NamedCSVView.swift
[33/175] Compiling Yams YamlError.swift
[34/175] Emitting module ArgumentParserToolInfo
[35/175] Compiling ArgumentParserToolInfo ToolInfo.swift
[37/210] Emitting module ArgumentParser
[38/214] Compiling ArgumentParser FishCompletionsGenerator.swift
[39/214] Compiling ArgumentParser ZshCompletionsGenerator.swift
[41/214] Compiling ArgumentParser Argument.swift
[42/214] Compiling ArgumentParser ArgumentHelp.swift
[43/217] Compiling ArgumentParser BashCompletionsGenerator.swift
[44/217] Compiling ArgumentParser CompletionsGenerator.swift
[45/217] Compiling SwiftCSV resource_bundle_accessor.swift
[49/217] Compiling ArgumentParser ParsableCommand.swift
[50/217] Compiling ArgumentParser ArgumentDecoder.swift
[51/217] Compiling ArgumentParser ArgumentDefinition.swift
[52/217] Compiling ArgumentParser CompletionKind.swift
[53/217] Compiling ArgumentParser Errors.swift
[58/217] Compiling SwiftCSV ParsingState.swift
[59/218] Compiling SwiftCSV Serializer.swift
[60/218] Compiling ArgumentParser Option.swift
[61/218] Compiling ArgumentParser OptionGroup.swift
[62/218] Compiling ArgumentParser Flag.swift
[63/218] Compiling ArgumentParser NameSpecification.swift
[64/218] Compiling ArgumentParser CommandConfiguration.swift
[65/218] Compiling ArgumentParser EnumerableFlag.swift
[68/219] Compiling Parsing Parser.swift
[69/219] Compiling AEXML Error.swift
[79/219] Emitting module BooleanExpressionEvaluation
[89/219] Compiling ArgumentParser ExpressibleByArgument.swift
[90/219] Compiling ArgumentParser ParsableArguments.swift
[91/219] Compiling ArgumentParser ParsableArgumentsValidation.swift
[92/219] Compiling ArgumentParser ArgumentSet.swift
[93/219] Compiling ArgumentParser CommandParser.swift
[94/219] Compiling ArgumentParser InputOrigin.swift
[95/219] Emitting module Splash
[96/219] Compiling Parsing Parser+Types.swift
[106/219] Compiling ArgumentParser DumpHelpGenerator.swift
[107/219] Compiling ArgumentParser HelpCommand.swift
[108/219] Compiling ArgumentParser HelpGenerator.swift
[109/219] Compiling ArgumentParser MessageInfo.swift
[110/219] Compiling ArgumentParser UsageGenerator.swift
[111/219] Compiling ArgumentParser CollectionExtensions.swift
[112/219] Compiling ArgumentParser SequenceExtensions.swift
[113/219] Compiling Parsing Character+Extensions.swift
[114/219] Compiling Parsing Parser+Operators.swift
[115/219] Emitting module Parsing
[118/219] Compiling Splash Segment.swift
[119/219] Compiling Splash TokenType.swift
[120/219] Compiling Splash Tokenizer.swift
[121/219] Compiling ArgumentParser ParserError.swift
[122/219] Compiling ArgumentParser SplitArguments.swift
[123/220] Compiling AEXML Builders.swift
[124/220] Compiling SwiftSoup TokeniserState.swift
[125/220] Compiling SwiftSoup TreeBuilder.swift
[126/220] Compiling SwiftSoup UnicodeScalar.swift
[127/220] Compiling SwiftSoup Validate.swift
[128/220] Compiling SwiftSoup Whitelist.swift
[129/220] Compiling SwiftSoup XmlDeclaration.swift
[130/220] Compiling SwiftSoup XmlTreeBuilder.swift
[146/220] Compiling SwiftSoup StructuralEvaluator.swift
[147/220] Compiling SwiftSoup SwiftSoup.swift
[148/220] Compiling SwiftSoup Tag.swift
[149/220] Compiling SwiftSoup TextNode.swift
[150/220] Compiling SwiftSoup Token.swift
[151/220] Compiling SwiftSoup TokenQueue.swift
[152/220] Compiling SwiftSoup Tokeniser.swift
[153/220] Compiling ArgumentParser StringExtensions.swift
[154/220] Compiling ArgumentParser Tree.swift
[155/220] Compiling SwiftSoup SimpleDictionary.swift
[156/220] Compiling SwiftSoup StreamReader.swift
[157/220] Compiling SwiftSoup String.swift
[158/220] Compiling SwiftSoup StringBuilder.swift
[159/220] Compiling SwiftSoup StringUtil.swift
[160/220] Compiling AEXML Options.swift
[161/220] Compiling AEXML Parser.swift
[163/221] Compiling AEXML Document.swift
[164/222] Compiling AEXML Element.swift
[173/223] Compiling BooleanExpressionEvaluation String+Extensions.swift
[174/224] Wrapping AST for SwiftCSV for debugging
[175/224] Wrapping AST for ArgumentParserToolInfo for debugging
[176/224] Wrapping AST for AEXML for debugging
[176/224] Wrapping AST for SwiftSoup for debugging
[178/224] Wrapping AST for Parsing for debugging
[184/224] Wrapping AST for Yams for debugging
[185/224] Wrapping AST for BooleanExpressionEvaluation for debugging
[187/295] Compiling Scout ExplorerValue+Add.swift
[188/295] Compiling Scout ExplorerValue+Delete.swift
[189/295] Compiling Scout ExplorerValue+Get.swift
[190/295] Compiling Scout ExplorerValue+Set.swift
[191/295] Compiling Scout PathElement.swift
[192/295] Compiling Scout PathElementRepresentable.swift
[193/295] Compiling Scout PathTree.swift
[194/296] Wrapping AST for Splash for debugging
[196/296] Compiling Scout ExplorerXML+Add.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[197/296] Compiling Scout ExplorerXML+CSVExport.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[198/296] Compiling Scout ExplorerXML+CSVImport.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[199/296] Compiling Scout ExplorerXML+Delete.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[200/296] Compiling Scout ExplorerXML+ExplorerValue.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[201/296] Compiling Scout ExplorerXML+Fold.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[202/296] Compiling Scout ExplorerXML+Get.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[203/296] Compiling Scout ExplorerXML+PathsListing.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[204/296] Compiling Scout ExplorerXML+Serialization.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
[205/296] Compiling Scout ExplorerXML+Set.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
56 | }
57 |
58 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
59 | keysTrees.forEach { (key, tree) in
60 | if let value = row[key] {
error: emit-module command failed with exit code 1 (use -v to see invocation)
[206/296] Emitting module Scout
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:41:54: error: reference to generic type 'CSV' requires arguments in <...>
39 | }
40 |
41 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
42 | let rootTree = Tree.root(name: "element")
43 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[207/372] Compiling Lux XMLEnhancedDelegate.swift
[208/372] Compiling Lux XMLEnhancedInjector.swift
[209/372] Compiling Lux XMLCategory.swift
[210/372] Compiling Lux XMLDelegate.swift
[211/372] Compiling Lux XMLInjector.swift
[212/372] Compiling Lux YAMLCategory.swift
[213/372] Compiling Lux YAMLDelegate.swift
[214/372] Compiling Lux YAMLInjector.swift
[215/372] Compiling Lux InjectorDelegate.swift
[216/372] Compiling Lux TextInjector.swift
[217/372] Compiling Lux JSONCategory.swift
[218/372] Compiling Lux JSONDelegate.swift
[219/372] Compiling Lux JSONInjector.swift
[220/372] Compiling Lux StringProtocol+Extensions.swift
[221/372] Compiling Lux AttributedInjector.swift
[222/372] Compiling Lux BaseInjector.swift
[223/372] Compiling Lux FileInjectionService.swift
[224/372] Compiling Lux InjectionService.swift
[225/372] Compiling Lux PlistCategory.swift
[226/372] Compiling Lux PlistDelegate.swift
[227/372] Compiling Lux PlistInjector.swift
[228/372] Compiling Lux HTMLCustomCSSOutputFormat.swift
[229/372] Compiling Lux SwiftCategory.swift
[230/373] Wrapping AST for ArgumentParser for debugging
[232/373] Compiling Scout PathExplorer+ExploreWithMemory.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[233/373] Compiling Scout PathExplorer+Helpers.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[234/373] Compiling Scout PathExplorer.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[235/373] Compiling Scout PathExplorers.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[236/373] Compiling Scout SerializablePathExplorer.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[237/373] Compiling Scout Path+Parsing.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[238/373] Compiling Scout PathsFilter.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[239/373] Compiling Scout ValuePredicate.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[240/373] Compiling Scout ValueTarget.swift
/host/spi-builder-workspace/Sources/Scout/Models/PathsFilter/ValuePredicate.swift:28:38: error: 'Expression' is ambiguous for type lookup in this context
26 | /// - note: Public wrapper around `BooleanExpressionEvaluation/Expression`
27 | public final class ExpressionPredicate: ValuePredicate {
28 | private(set) var expression: Expression
| `- error: 'Expression' is ambiguous for type lookup in this context
29 |
30 | /// The value types that the operators in the expression support
/host/spi-builder-workspace/.build/checkouts/BooleanExpressionEvaluation/Sources/BooleanExpressionEvaluation/Expression/Expression.swift:9:15: note: found this candidate
7 |
8 | /// Represents a boolean expression as an array of `ExpressionElements`
9 | public struct Expression: Collection, CustomStringConvertible {
| `- note: found this candidate
10 |
11 | public typealias Element = ExpressionElement
FoundationEssentials.Expression:2:15: note: found this candidate
1 | @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
2 | public struct Expression<each Input, Output> : Sendable {
| `- note: found this candidate
3 | public let expression: any StandardPredicateExpression<Output>
4 | public let variable: (repeat PredicateExpressions.Variable<each Input>)
[241/373] Compiling Lux DraculaThemeInjectorDelegate.swift
[242/373] Compiling Lux JSONDracula.swift
[243/373] Compiling Lux PlistDracula.swift
[244/373] Compiling Lux SwiftDracula.swift
[245/373] Compiling Lux XMLEnhancedDracula.swift
[246/373] Compiling Lux XmlDracula.swift
[247/373] Compiling Lux YAMLDracula.swift
[248/373] Compiling Lux ZshDracula.swift
[249/373] Compiling Lux ThemeInjectorDelegate.swift
[250/382] Compiling Lux JSONXcodeDarkDelegate.swift
[251/382] Compiling Lux PlistXcodeDarkDelegate.swift
[252/382] Compiling Lux SwiftXcodeDarkDelegate.swift
[253/382] Compiling Lux XMLEnhancedXcodeDarkDelegate.swift
[254/382] Compiling Lux XcodeDarkPalette.swift
[255/382] Compiling Lux XcodeDarkThemeInjectorDelegate.swift
[256/382] Compiling Lux XmlXcodeDarkDelegate.swift
[257/382] Compiling Lux YAMLXcodeDarkDelegate.swift
[258/382] Compiling Lux ZshXcodeDarkDelegate.swift
[259/382] Compiling Lux Category.swift
[260/382] Compiling Lux Color.swift
[261/382] Compiling Lux InjectionType.swift
[262/382] Compiling Lux InjectorType.swift
[263/382] Compiling Lux RegexPattern.swift
[264/382] Compiling Lux TerminalModifier.swift
[265/382] Compiling Lux TextType.swift
[266/382] Compiling Lux ColorTheme.swift
[267/382] Compiling Lux DraculaPalette.swift
[274/382] Compiling Lux JSONXcodeDefaultDelegate.swift
[275/382] Compiling Lux PlistXcodeDefaultDelegate.swift
[276/382] Compiling Lux SwiftXcodeDefaultDelegate.swift
[277/382] Compiling Lux XcodeLightPalette.swift
[278/382] Compiling Lux SwiftDelegate.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[279/382] Compiling Lux SwiftInjector.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[280/382] Compiling Lux TerminalOutputFormat.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[281/382] Compiling Lux TokenType+SwiftCategory.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[282/382] Compiling Lux XMLEnhancedCategory.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[291/382] Compiling Lux ZshCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[292/382] Compiling Lux ZshDelegate.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[293/382] Compiling Lux ZshInjector.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[294/382] Compiling Lux Appendable.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[295/382] Compiling Lux AttributedString.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[296/382] Compiling Lux CSSClass.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:18:35: error: reference to generic type 'CSV' requires arguments in <...>
16 | }
17 |
18 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
19 | if headers {
20 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:28:54: error: reference to generic type 'CSV' requires arguments in <...>
26 | }
27 |
28 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
29 | let rootTree = Tree.root()
30 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:23: error: generic parameter 'DataView' could not be inferred
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:14:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
12 |
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
15 | return try from(csv: csv, headers: hasHeaders)
16 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: extra arguments at positions #1, #2 in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
16 | }
17 |
:
40 | }
41 |
42 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
43 | keysTrees.forEach { (key, tree) in
44 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:15:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
13 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
14 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
15 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
16 | }
17 |
[312/382] Compiling Lux XcodeLightThemeInjectorDelegate.swift
[313/382] Compiling Lux XmlEnhancedXcodeDefaultDelegate.swift
[314/382] Compiling Lux XmlXcodeDefaultDelegate.swift
[315/382] Compiling Lux YAMLXcodeDefaultLightDelegate.swift
[316/382] Compiling Lux ZshXcodeLightDelegate.swift
[346/382] Emitting module Lux
[347/382] Compiling Lux DataFormat.swift
[348/382] Compiling Lux Version.swift
[349/382] Compiling Lux Bool+KeyPath.swift
[350/382] Compiling Lux NSRegularExpression+Extensions.swift
[351/382] Compiling Lux String+Extensions.swift
[357/383] Wrapping AST for Lux for debugging
BUILD FAILURE 6.2 linux