Swift Package IndexBuild Information
Failed to build Scout, reference master (2cd10a), with Swift 5.10 for Linux on 19 Oct 2025 15:33:21 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-1":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/finestructure/spi-images:basic-5.10-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
========================================
RunAll
========================================
Builder version: 4.68.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/ABridoux/scout.git
Reference: master
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
* branch master -> FETCH_HEAD
* [new branch] master -> origin/master
HEAD is now at 2cd10a0 Updated README for Wiki links
Cloned https://github.com/ABridoux/scout.git
Revision (git rev-parse @):
2cd10a0c61a3488b1e126eaca5806016a3eabe46
SUCCESS checkout https://github.com/ABridoux/scout.git at master
========================================
Build
========================================
Selected platform: linux
Swift version: 5.10
Building package at path: $PWD
https://github.com/ABridoux/scout.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4606859-1":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/finestructure/spi-images:basic-5.10-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-5.10-latest: Pulling from finestructure/spi-images
Digest: sha256:876c9f54cbb08e857839f8acb28beadbc9bf56a8488855996222d9f683e93e2f
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-5.10-latest
Fetching https://github.com/apple/swift-docc-plugin
Fetching https://github.com/swiftcsv/SwiftCSV
Fetching https://github.com/ABridoux/lux
Fetching https://github.com/ABridoux/BooleanExpressionEvaluation
Fetching https://github.com/apple/swift-argument-parser
Fetching https://github.com/jpsim/Yams.git
[1/541] Fetching booleanexpressionevaluation
[483/2321] Fetching booleanexpressionevaluation, swiftcsv
[1765/3862] Fetching booleanexpressionevaluation, swiftcsv, lux
[2433/20544] Fetching booleanexpressionevaluation, swiftcsv, lux, swift-argument-parser
[2600/22677] Fetching booleanexpressionevaluation, swiftcsv, lux, swift-argument-parser, swift-docc-plugin
[3336/33946] Fetching booleanexpressionevaluation, swiftcsv, lux, swift-argument-parser, swift-docc-plugin, yams
Fetched https://github.com/apple/swift-docc-plugin from cache (0.60s)
[19796/31813] Fetching booleanexpressionevaluation, swiftcsv, lux, swift-argument-parser, yams
Fetching https://github.com/tadija/AEXML.git
[26518/33940] Fetching booleanexpressionevaluation, swiftcsv, lux, swift-argument-parser, yams, aexml
Fetched https://github.com/tadija/AEXML.git from cache (0.42s)
Fetched https://github.com/swiftcsv/SwiftCSV from cache (1.03s)
Fetched https://github.com/ABridoux/BooleanExpressionEvaluation from cache (1.03s)
Fetched https://github.com/ABridoux/lux from cache (1.05s)
[24345/27951] Fetching swift-argument-parser, yams
Fetched https://github.com/apple/swift-argument-parser from cache (1.05s)
[7889/11269] Fetching yams
Fetched https://github.com/jpsim/Yams.git from cache (1.80s)
Computing version for https://github.com/ABridoux/BooleanExpressionEvaluation
Computed https://github.com/ABridoux/BooleanExpressionEvaluation at 2.0.1 (0.71s)
Computing version for https://github.com/tadija/AEXML.git
Computed https://github.com/tadija/AEXML.git at 4.7.0 (0.73s)
Computing version for https://github.com/jpsim/Yams.git
Computed https://github.com/jpsim/Yams.git at 4.0.6 (0.78s)
Computing version for https://github.com/apple/swift-docc-plugin
Computed https://github.com/apple/swift-docc-plugin at 1.4.5 (1.04s)
Fetching https://github.com/swiftlang/swift-docc-symbolkit
[1/3553] Fetching swift-docc-symbolkit
Fetched https://github.com/swiftlang/swift-docc-symbolkit from cache (0.58s)
Computing version for https://github.com/swiftlang/swift-docc-symbolkit
Computed https://github.com/swiftlang/swift-docc-symbolkit at 1.0.0 (0.54s)
Computing version for https://github.com/swiftcsv/SwiftCSV
Computed https://github.com/swiftcsv/SwiftCSV at 0.10.0 (0.48s)
Computing version for https://github.com/ABridoux/lux
Computed https://github.com/ABridoux/lux at 0.5.0 (0.49s)
Fetching https://github.com/JohnSundell/Splash
Fetching https://github.com/scinfu/SwiftSoup.git
[1/2173] Fetching splash
[2174/6807] Fetching splash, swiftsoup
Fetched https://github.com/JohnSundell/Splash from cache (0.51s)
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 (0.52s)
Computing version for https://github.com/scinfu/SwiftSoup.git
Computed https://github.com/scinfu/SwiftSoup.git at 1.7.5 (1.36s)
Computing version for https://github.com/apple/swift-argument-parser
Computed https://github.com/apple/swift-argument-parser at 0.5.0 (0.50s)
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/apple/swift-docc-plugin
Working copy of https://github.com/apple/swift-docc-plugin resolved at 1.4.5
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/JohnSundell/Splash
Working copy of https://github.com/JohnSundell/Splash resolved at 0.16.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/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/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/scinfu/SwiftSoup.git
Working copy of https://github.com/scinfu/SwiftSoup.git resolved at 1.7.5
Creating working copy for https://github.com/ABridoux/BooleanExpressionEvaluation
Working copy of https://github.com/ABridoux/BooleanExpressionEvaluation resolved at 2.0.1
Creating working copy for https://github.com/ABridoux/lux
Working copy of https://github.com/ABridoux/lux resolved at 0.5.0
[1/1] Compiling plugin Swift-DocC
[2/2] Compiling plugin Swift-DocC Preview
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] Write swift-version-24593BA9C3E375BF.txt
[21/38] Compiling emitter.c
[22/39] Compiling scanner.c
[24/166] Emitting module Parsing
[25/166] Compiling Yams Mark.swift
[26/166] Compiling Yams Node.Mapping.swift
[27/167] Compiling SwiftCSV String+Lines.swift
[28/167] Compiling AEXML Builders.swift
[29/167] Emitting module AEXML
[30/168] Compiling SwiftCSV NamedCSVView.swift
[31/168] Compiling Yams YamlError.swift
[32/168] Emitting module ArgumentParserToolInfo
[33/168] Compiling ArgumentParserToolInfo ToolInfo.swift
[35/203] Compiling Parsing Parser.swift
[36/203] Compiling ArgumentParser InputOrigin.swift
[37/203] Compiling ArgumentParser Name.swift
[38/203] Compiling ArgumentParser Parsed.swift
[39/206] Emitting module BooleanExpressionEvaluation
[40/206] Compiling ArgumentParser BashCompletionsGenerator.swift
[41/206] Compiling ArgumentParser CompletionsGenerator.swift
[44/207] Compiling ArgumentParser Flag.swift
[45/207] Compiling ArgumentParser CompletionKind.swift
[46/207] Compiling ArgumentParser Errors.swift
[47/207] Compiling ArgumentParser NameSpecification.swift
[48/207] Compiling ArgumentParser Option.swift
[49/207] Compiling ArgumentParser HelpCommand.swift
[50/207] Compiling ArgumentParser HelpGenerator.swift
[51/207] Compiling ArgumentParser MessageInfo.swift
[52/207] Compiling ArgumentParser OptionGroup.swift
[53/207] Compiling ArgumentParser CommandConfiguration.swift
[54/207] Compiling ArgumentParser EnumerableFlag.swift
[55/207] Compiling ArgumentParser ExpressibleByArgument.swift
[56/207] Compiling ArgumentParser ArgumentSet.swift
[57/207] Compiling ArgumentParser CommandParser.swift
[58/207] Compiling ArgumentParser FishCompletionsGenerator.swift
[59/207] Compiling ArgumentParser ZshCompletionsGenerator.swift
[60/207] Emitting module Splash
[65/207] Compiling ArgumentParser Argument.swift
[66/207] Compiling ArgumentParser ArgumentHelp.swift
[77/207] Emitting module SwiftCSV
[78/207] Compiling SwiftSoup Selector.swift
[79/207] Compiling SwiftSoup SerializationException.swift
[80/207] Compiling SwiftSoup SimpleDictionary.swift
[81/207] Compiling SwiftSoup StreamReader.swift
[82/207] Compiling SwiftSoup String.swift
[83/207] Compiling SwiftSoup StringBuilder.swift
[84/207] Compiling SwiftSoup StringUtil.swift
[100/214] Compiling SwiftSoup StructuralEvaluator.swift
[101/214] Compiling SwiftSoup SwiftSoup.swift
[102/214] Compiling SwiftSoup Tag.swift
[103/214] Compiling SwiftSoup TextNode.swift
[104/214] Compiling SwiftSoup Token.swift
[105/214] Compiling SwiftSoup TokenQueue.swift
[106/214] Compiling SwiftSoup Tokeniser.swift
[111/214] Emitting module Yams
[114/214] Compiling SwiftCSV Parser.swift
[115/214] Compiling SwiftCSV Serializer.swift
[116/214] Compiling SwiftCSV ParsingState.swift
[117/215] Compiling AEXML Error.swift
[118/215] Compiling AEXML Document.swift
[119/215] Compiling Parsing Parser+Types.swift
[120/215] Compiling SwiftCSV resource_bundle_accessor.swift
[121/216] Compiling AEXML Options.swift
[122/216] Compiling AEXML Parser.swift
[123/216] Compiling Parsing Character+Extensions.swift
[124/216] Compiling Parsing Parser+Operators.swift
[126/217] Compiling AEXML Element.swift
[127/217] Compiling ArgumentParser ParsableArguments.swift
[128/217] Compiling ArgumentParser ParsableArgumentsValidation.swift
[129/217] Compiling ArgumentParser ParsableCommand.swift
[130/217] Compiling ArgumentParser ArgumentDecoder.swift
[131/217] Compiling ArgumentParser ArgumentDefinition.swift
[132/217] Compiling SwiftSoup NodeVisitor.swift
[133/217] Compiling SwiftSoup OrderedDictionary.swift
[136/217] Compiling Splash Segment.swift
[137/217] Compiling Splash TokenType.swift
[138/217] Compiling Splash Tokenizer.swift
[139/217] Compiling ArgumentParser SplitArguments.swift
[140/217] Compiling ArgumentParser DumpHelpGenerator.swift
[149/218] Emitting module SwiftSoup
[158/218] Compiling BooleanExpressionEvaluation String+Extensions.swift
[165/223] Wrapping AST for ArgumentParserToolInfo for debugging
[166/223] Wrapping AST for Yams for debugging
[167/223] Wrapping AST for SwiftCSV for debugging
[168/223] Wrapping AST for Parsing for debugging
[169/223] Wrapping AST for AEXML for debugging
[170/223] Wrapping AST for BooleanExpressionEvaluation for debugging
[176/283] Emitting module ArgumentParser
[177/283] Compiling Scout ExplorerValueDecodingContainer.swift
[178/283] Compiling Scout ExplorerValueSingleDecodingContainer.swift
[179/283] Compiling Scout ExplorerValueUnkeyedDecodingContainer.swift
[180/283] Compiling Scout DecodingError+Extensions.swift
[181/283] Compiling Scout ExplorerValueEncoder.swift
[181/305] Wrapping AST for Splash for debugging
[183/305] Compiling Scout ExplorerXML+CSVExport.swift
[184/305] Compiling Scout ExplorerXML+CSVImport.swift
[185/305] Compiling Scout ExplorerXML+Delete.swift
[186/305] Compiling Scout ExplorerXML+ExplorerValue.swift
[187/305] Compiling Scout ExplorerValue+CSVImport.swift
[188/305] Compiling Scout ExplorerValue.swift
[189/305] Compiling Scout ExplorerValue+Codable.swift
[190/305] Compiling Scout ExplorerValue+Convenience.swift
[191/305] Compiling Scout ExplorerValue+Add.swift
[192/305] Compiling Scout ExplorerValue+Delete.swift
[193/305] Compiling Scout ExplorerValue+Get.swift
[194/305] Compiling Scout ExplorerValue+Set.swift
[195/305] Compiling Scout ExplorerValue+CSVExport.swift
[196/305] Compiling Scout ExplorerXML+SingleChildStrategy.swift
[197/305] Compiling Scout ExplorerXML+ValueSetter.swift
[198/305] Compiling Scout ExplorerValue+CustomStringConvertible.swift
[199/305] Compiling Scout ExplorerValue+ExpressibleBy.swift
error: emit-module command failed with exit code 1 (use -v to see invocation)
[200/305] Emitting module Scout
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
[201/316] Compiling Scout ExplorerXML+Fold.swift
[202/316] Compiling Scout ExplorerXML+Get.swift
[203/316] Compiling Scout ExplorerXML+PathsListing.swift
[204/316] Compiling Scout ExplorerXML+Serialization.swift
[205/316] Compiling Scout ExplorerXML+Set.swift
[206/316] Compiling Scout SerializationError.swift
[207/316] Compiling Scout ExplorerXML+Add.swift
[208/316] Compiling Scout DataFormat.swift
[209/316] Compiling Scout Folding.swift
[210/316] Compiling Scout ScoutVersion.swift
[211/317] Wrapping AST for ArgumentParser for debugging
[213/317] Compiling Scout Optional+Extensions.swift
[214/317] Compiling Scout Slice+Etensions.swift
[215/317] Compiling Scout String+Extension.swift
[216/317] Compiling Scout String+Jaro-Winkler.swift
[217/317] Compiling Scout ExplorerError.swift
[218/317] Compiling Scout PathError.swift
[219/317] Compiling Scout Bounds+Bound.swift
[220/317] Compiling Scout Bounds+IntWrapper.swift
[221/317] Compiling Scout Bounds.swift
[222/317] Compiling Scout Path+Flattening.swift
[223/317] Compiling Scout Path+Miscellaneous.swift
[224/317] Compiling Scout ExplorerXML.swift
[225/317] Compiling Scout AEXMLElement+Children.swift
[226/317] Compiling Scout AEXMLElement+Equal.swift
[227/317] Compiling Scout AEXMLElement+Group.swift
[228/317] Compiling Scout Array+Extensions.swift
[229/317] Compiling Scout CodingKey+Extensions.swift
[230/317] Compiling Scout Collection+Extensions.swift
[231/317] Compiling Scout Collection+Path.swift
[232/317] Compiling Scout Dictionary+Extensions.swift
[233/317] Compiling Scout Int+LastIndex.swift
[234/317] Compiling Scout NSRegularExpression+Extensions.swift
[235/317] Compiling Scout Path+StringConvertible.swift
[236/317] Compiling Scout Path.swift
[237/317] Compiling Scout PathElement+Convenience.swift
[238/317] Compiling Scout PathElement.swift
[239/317] Compiling Scout PathElementRepresentable.swift
[240/317] Compiling Scout PathTree+ValueType.swift
[241/317] Compiling Scout PathTree.swift
[242/317] Compiling Scout CodablePathExplorer+Serialization.swift
[243/317] Compiling Scout CodablePathExplorer.swift
[244/317] Compiling Scout EquatablePathExplorer.swift
[245/317] Compiling Scout PathExplorer+Convenience.swift
[253/318] Compiling Scout PathExplorer+ExploreWithMemory.swift
[254/318] Compiling Scout PathExplorer+Helpers.swift
[255/318] Compiling Scout PathExplorer.swift
[256/318] Compiling Scout PathExplorers.swift
[257/318] Compiling Scout SerializablePathExplorer.swift
[258/318] Compiling Scout Path+Parsing.swift
[259/318] Compiling Scout PathsFilter+ExpressionPredicate.swift
[260/318] Compiling Scout PathsFilter+FunctionPredicate.swift
[261/318] Compiling Scout PathsFilter.swift
[262/318] Compiling Scout ValuePredicate.swift
[263/318] Compiling Scout ValueTarget.swift
[264/318] Wrapping AST for SwiftSoup for debugging
[266/385] Compiling Lux TerminalOutputFormat.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[267/385] Compiling Lux TokenType+SwiftCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[268/385] Compiling Lux XMLEnhancedCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[269/385] Compiling Lux XMLEnhancedDelegate.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[270/385] Compiling Lux XMLEnhancedInjector.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[271/385] Compiling Lux XMLCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[272/385] Compiling Lux XMLDelegate.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[273/385] Compiling Lux XMLInjector.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[274/385] Compiling Lux Category.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[275/385] Compiling Lux Color.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[276/385] Compiling Lux InjectionType.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[277/385] Compiling Lux InjectorType.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:44:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: coalesce using '??' to provide a default when the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
?? <#default value#>
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
return try from(csv: csv, headers: hasHeaders)
^
!
[278/385] Compiling Lux DataFormat.swift
[279/385] Compiling Lux Version.swift
[280/385] Compiling Lux Bool+KeyPath.swift
[281/385] Compiling Lux NSRegularExpression+Extensions.swift
[282/385] Compiling Lux String+Extensions.swift
[283/385] Compiling Lux StringProtocol+Extensions.swift
[284/385] Compiling Lux AttributedInjector.swift
[285/385] Compiling Lux BaseInjector.swift
[286/385] Compiling Lux FileInjectionService.swift
[287/385] Compiling Lux InjectionService.swift
[288/385] Compiling Lux SwiftDelegate.swift
[289/385] Compiling Lux SwiftInjector.swift
[290/385] Compiling Lux RegexPattern.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[291/385] Compiling Lux TerminalModifier.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[292/385] Compiling Lux TextType.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[293/385] Compiling Lux ColorTheme.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[294/385] Compiling Lux DraculaPalette.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[295/385] Compiling Lux InjectorDelegate.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[296/385] Compiling Lux TextInjector.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[297/385] Compiling Lux JSONCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[298/385] Compiling Lux JSONDelegate.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[299/385] Compiling Lux JSONInjector.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[300/385] Compiling Lux PlistCategory.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
open class CSV<DataView : CSVView> {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: note: explicitly specify the generic arguments to fix this issue
let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
^
<<#DataView: CSVView#>>
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
return try from(csv: csv, headers: hasHeaders)
^
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:60:25: note: 'from(row:with:rootTree:)' declared here
private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
^
[301/385] Compiling Lux PlistDelegate.swift
[302/385] Compiling Lux PlistInjector.swift
[303/385] Compiling Lux HTMLCustomCSSOutputFormat.swift
[304/385] Compiling Lux SwiftCategory.swift
[305/385] Compiling Lux DraculaThemeInjectorDelegate.swift
[306/385] Compiling Lux JSONDracula.swift
[307/385] Compiling Lux PlistDracula.swift
[308/385] Compiling Lux SwiftDracula.swift
[309/385] Compiling Lux XMLEnhancedDracula.swift
[310/385] Compiling Lux XmlDracula.swift
[311/385] Compiling Lux YAMLDracula.swift
[312/385] Compiling Lux ZshDracula.swift
[321/385] Compiling Lux ThemeInjectorDelegate.swift
[322/394] Emitting module Lux
error: fatalError
BUILD FAILURE 5.10 linux