Logs - sovt/spata - Community Build Dashboard

1##################################

2Clonning https://github.com/sovt/spata.git into /build/repo using revision v3.2.2

3##################################

4Note: switching to '61662577c72e2f326deeda9f741b47c6a0ba987b'.

5

6You are in 'detached HEAD' state. You can look around, make experimental

7changes and commit them, and you can discard any commits you make in this

8state without impacting any branches by switching back to a branch.

9

10If you want to create a new branch to retain commits you create, you may

11do so (now or later) by using -c with the switch command. Example:

12

13 git switch -c <new-branch-name>

14

15Or undo this operation with:

16

17 git switch -

18

19Turn off this advice by setting config variable advice.detachedHead to false

20

21Using target Scala version for migration: 3.7.4

22Migrating project for -source:3.5 using Scala 3.7.4

23----

24Preparing build for 3.7.4

25Would try to apply common scalacOption (best-effort, sbt/mill only):

26Append: -rewrite,REQUIRE:-source:3.5-migration

27Remove: -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

28----

29Starting build for 3.7.4

30Execute tests: false

31sbt project found:

32Sbt version 1.10.11

33 is not supported, minimal supported version is 1.11.5

34Enforcing usage of sbt in version 1.11.5

35No prepare script found for project sovt/spata

36##################################

37Scala version: 3.7.4

38Targets: info.fingo%spata

39Project projectConfig: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5","3.7"],"sourcePatches":[]}

40##################################

41Using extra scalacOptions: -rewrite,REQUIRE:-source:3.5-migration

42Filtering out scalacOptions: -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

43[sbt_options] declare -a sbt_options=()

44[process_args] java_version = '17'

45[copyRt] java9_rt = '/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8/rt.jar'

46# Executing command line:

47java

48-Dfile.encoding=UTF-8

49-Dcommunitybuild.scala=3.7.4

50-Dcommunitybuild.project.dependencies.add=

51-Xmx7G

52-Xms4G

53-Xss8M

54-Dsbt.script=/root/.sdkman/candidates/sbt/current/bin/sbt

55-Dscala.ext.dirs=/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8

56-jar

57/root/.sdkman/candidates/sbt/1.11.5/bin/sbt-launch.jar

58"setCrossScalaVersions 3.7.4"

59"++3.7.4 -v"

60"mapScalacOptions "-rewrite,REQUIRE:-source:3.5-migration,-Wconf:msg=can be rewritten automatically under:s" "-indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e""

61"set every credentials := Nil"

62"excludeLibraryDependency com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}"

63"removeScalacOptionsStartingWith -P:wartremover"

64

65moduleMappings

66"runBuild 3.7.4 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5","3.7"],"sourcePatches":[]}""" info.fingo%spata"

67

68[info] welcome to sbt 1.11.5 (Eclipse Adoptium Java 17.0.8)

69[info] loading settings for project repo-build from akka.sbt, plugins.sbt...

70[info] loading project definition from /build/repo/project

71[info] compiling 2 Scala sources to /build/repo/project/target/scala-2.12/sbt-1.0/classes ...

72[info] Non-compiled module 'compiler-bridge_2.12' for Scala 2.12.20. Compiling...

73[info] Compilation completed in 8.805s.

74[info] done compiling

75[info] loading settings for project root from build.sbt...

76[info] set current project to spata (in build file:/build/repo/)

77Execute setCrossScalaVersions: 3.7.4

78OpenCB::Changing crossVersion 3.3.5 -> 3.7.4 in root/crossScalaVersions

79OpenCB::Limitting incorrect crossVersions List(2.12.20) -> List(3.7.4) in root/crossScalaVersions

80[info] set current project to spata (in build file:/build/repo/)

81[info] Setting Scala version to 3.7.4 on 1 projects.

82[info] Switching Scala version on:

83[info] * root (3.7.4)

84[info] Excluding projects:

85[info] Reapplying settings...

86[info] set current project to spata (in build file:/build/repo/)

87Execute mapScalacOptions: -rewrite,REQUIRE:-source:3.5-migration,-Wconf:msg=can be rewritten automatically under:s -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

88[info] Reapplying settings...

89[info] set current project to spata (in build file:/build/repo/)

90[info] Defining Global / credentials, credentials

91[info] The new values will be used by Compile / scalafmtOnly, Global / pgpSelectPassphrase and 8 others.

92[info] Run `last` for details.

93[info] Reapplying settings...

94[info] set current project to spata (in build file:/build/repo/)

95Execute excludeLibraryDependency: com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}

96[info] Reapplying settings...

97OpenCB::Failed to reapply settings in excludeLibraryDependency: Reference to undefined setting:

98

99 Global / allExcludeDependencies from Global / allExcludeDependencies (CommunityBuildPlugin.scala:331)

100 Did you mean allExcludeDependencies ?

101 , retry without global scopes

102[info] Reapplying settings...

103[info] set current project to spata (in build file:/build/repo/)

104Execute removeScalacOptionsStartingWith: -P:wartremover

105[info] Reapplying settings...

106[info] set current project to spata (in build file:/build/repo/)

107[success] Total time: 0 s, completed Jan 13, 2026, 7:18:17 PM

108Build config: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5","3.7"],"sourcePatches":[]}

109Parsed config: Success(ProjectBuildConfig(ProjectsConfig(List(),Map()),CompileOnly,List()))

110Starting build...

111Projects: Set(root)

112Starting build for ProjectRef(file:/build/repo/,root) (spata)... [0/1]

113OpenCB::Exclude Scala3 specific scalacOption `-rewrite` in Scala 2.12.20 module Global

114OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.5-migration` in Scala 2.12.20 module Global

115OpenCB::Filter out '-deprecation', matches setting pattern '^-?-deprecation'

116OpenCB::Filter out '-feature', matches setting pattern '^-?-feature'

117OpenCB::Filter out '-new-syntax', matches setting pattern '^-?-new-syntax'

118OpenCB::Filter out '-Wconf:cat=deprecation:w,any:e', matches regex '.*-Wconf.*any:e'

119Compile scalacOptions: -explain, -explain-types, -language:existentials, -language:higherKinds, -language:implicitConversions, -pagewidth:120, -release:11, -unchecked, -Wvalue-discard, -Wunused:all, -Wnonunit-statement, -Xverify-signatures, -Xsemanticdb, -semanticdb-target, /build/repo/target/scala-3.7.4/meta, -rewrite, -Wconf:msg=can be rewritten automatically under:s, -source:3.5-migration

120[info] compiling 33 Scala sources to /build/repo/target/scala-3.7.4/classes ...

121[error] -- [E007] Type Mismatch Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:93:34 --------------

122[error] 93 | val vals = labels.map(l => get(l, keys, values))

123[error] | ^^^^^^^^^^^^^^^^^^^^

124[error] | Found: info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

125[error] | Required: KS match {

126[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

127[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

128[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

129[error] | (VS match {

130[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

131[error] | })

132[error] |

133[error] | where: KS is a type in class TypedRecord with bounds <: Tuple

134[error] | VS is a type in class TypedRecord with bounds <: Tuple

135[error] | _ is a type variable with constraint <: Tuple

136[error] | _² is a type variable

137[error] |

138[error] |

139[error] | Note: a match type could not be fully reduced:

140[error] |

141[error] | trying to reduce info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

142[error] | failed since selector KS

143[error] | does not match case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

144[error] | and cannot be shown to be disjoint from it either.

145[error] | Therefore, reduction cannot advance to the remaining case

146[error] |

147[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS]

148[error] |--------------------------------------------------------------------------------------------------------------------

149[error] | Explanation (enabled by `-explain`)

150[error] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

151[error] |

152[error] | Tree:

153[error] |

154[error] | this.get[(l : String), KS, VS](l, TypedRecord.this.keys, TypedRecord.this.values)

155[error] |

156[error] | I tried to show that

157[error] | info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

158[error] | conforms to

159[error] | KS match {

160[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

161[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

162[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

163[error] | (VS match {

164[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

165[error] | })

166[error] | but none of the attempts shown below succeeded:

167[error] |

168[error] | ==> info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

169[error] | ==> KS match { case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

170[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

171[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

172[error] | ==> VS match { case h *: _ => h } <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

173[error] | ==> Any <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] }) = false

174[error] | ==> VS <: KS

175[error] | ==> VS <: Nothing in frozen constraint

176[error] | ==> Tuple <: Nothing in frozen constraint = false

177[error] | ==> Tuple <: Nothing in frozen constraint = false

178[error] | ==> Tuple <: KS

179[error] | ==> Tuple <: Nothing in frozen constraint = false

180[error] | ==> Tuple <: KS in frozen constraint

181[error] | ==> Tuple <: Nothing in frozen constraint = false

182[error] | ==> [_ <: Tuple] =>> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: [_ <: Tuple] =>> scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

183[error] | ==> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

184[error] | ==> ? <: String *: _ <: (l : String) *: _

185[error] | ==> Any <: (l : String) = false

186[error] |

187[error] | The tests were made under a constraint with:

188[error] | uninstantiated variables: B

189[error] | constrained types: [B](f: String => B): List[B], [B](f: String => B): List[B]

190[error] | bounds:

191[error] | B

192[error] | B :=

193[error] | KS match {

194[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

195[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

196[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

197[error] | (VS match {

198[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

199[error] | })

200[error] | ordering:

201[error] | co-deps:

202[error] | contra-deps:

203[error] --------------------------------------------------------------------------------------------------------------------

204[error] -- [E172] Type Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:94:46 -----------------------

205[error] 94 | m.fromProduct(Tuple.fromArray(vals.toArray))

206[error] | ^

207[error] | No ClassTag available for T

208[error] |

209[error] | where: T is a type variable with constraint >: KS match {

210[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

211[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

212[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

213[error] | (VS match {

214[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

215[error] | })

216[error] two errors found

217[error] (Compile / compileIncremental) Compilation failed

218[info] compiling 33 Scala sources to /build/repo/target/scala-3.7.4/classes ...

219[error] -- [E007] Type Mismatch Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:93:34 --------------

220[error] 93 | val vals = labels.map(l => get(l, keys, values))

221[error] | ^^^^^^^^^^^^^^^^^^^^

222[error] | Found: info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

223[error] | Required: KS match {

224[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

225[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

226[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

227[error] | (VS match {

228[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

229[error] | })

230[error] |

231[error] | where: KS is a type in class TypedRecord with bounds <: Tuple

232[error] | VS is a type in class TypedRecord with bounds <: Tuple

233[error] | _ is a type variable with constraint <: Tuple

234[error] | _² is a type variable

235[error] |

236[error] |

237[error] | Note: a match type could not be fully reduced:

238[error] |

239[error] | trying to reduce info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

240[error] | failed since selector KS

241[error] | does not match case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

242[error] | and cannot be shown to be disjoint from it either.

243[error] | Therefore, reduction cannot advance to the remaining case

244[error] |

245[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS]

246[error] |--------------------------------------------------------------------------------------------------------------------

247[error] | Explanation (enabled by `-explain`)

248[error] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

249[error] |

250[error] | Tree:

251[error] |

252[error] | this.get[(l : String), KS, VS](l, TypedRecord.this.keys, TypedRecord.this.values)

253[error] |

254[error] | I tried to show that

255[error] | info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

256[error] | conforms to

257[error] | KS match {

258[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

259[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

260[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

261[error] | (VS match {

262[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

263[error] | })

264[error] | but none of the attempts shown below succeeded:

265[error] |

266[error] | ==> info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

267[error] | ==> KS match { case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

268[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

269[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

270[error] | ==> VS match { case h *: _ => h } <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

271[error] | ==> Any <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] }) = false

272[error] | ==> VS <: KS

273[error] | ==> VS <: Nothing in frozen constraint

274[error] | ==> Tuple <: Nothing in frozen constraint = false

275[error] | ==> Tuple <: Nothing in frozen constraint = false

276[error] | ==> Tuple <: KS

277[error] | ==> Tuple <: Nothing in frozen constraint = false

278[error] | ==> Tuple <: KS in frozen constraint

279[error] | ==> Tuple <: Nothing in frozen constraint = false

280[error] | ==> [_ <: Tuple] =>> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: [_ <: Tuple] =>> scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

281[error] | ==> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

282[error] | ==> ? <: String *: _ <: (l : String) *: _

283[error] | ==> Any <: (l : String) = false

284[error] |

285[error] | The tests were made under a constraint with:

286[error] | uninstantiated variables: B

287[error] | constrained types: [B](f: String => B): List[B], [B](f: String => B): List[B]

288[error] | bounds:

289[error] | B

290[error] | B :=

291[error] | KS match {

292[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

293[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

294[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

295[error] | (VS match {

296[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

297[error] | })

298[error] | ordering:

299[error] | co-deps:

300[error] | contra-deps:

301[error] --------------------------------------------------------------------------------------------------------------------

302[error] -- [E172] Type Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:94:46 -----------------------

303[error] 94 | m.fromProduct(Tuple.fromArray(vals.toArray))

304[error] | ^

305[error] | No ClassTag available for T

306[error] |

307[error] | where: T is a type variable with constraint >: KS match {

308[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

309[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

310[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

311[error] | (VS match {

312[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

313[error] | })

314[error] two errors found

315[error] (Compile / compileIncremental) Compilation failed

316[info] compiling 33 Scala sources to /build/repo/target/scala-3.7.4/classes ...

317[error] -- [E007] Type Mismatch Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:93:34 --------------

318[error] 93 | val vals = labels.map(l => get(l, keys, values))

319[error] | ^^^^^^^^^^^^^^^^^^^^

320[error] | Found: info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

321[error] | Required: KS match {

322[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

323[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

324[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

325[error] | (VS match {

326[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

327[error] | })

328[error] |

329[error] | where: KS is a type in class TypedRecord with bounds <: Tuple

330[error] | VS is a type in class TypedRecord with bounds <: Tuple

331[error] | _ is a type variable with constraint <: Tuple

332[error] | _² is a type variable

333[error] |

334[error] |

335[error] | Note: a match type could not be fully reduced:

336[error] |

337[error] | trying to reduce info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

338[error] | failed since selector KS

339[error] | does not match case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

340[error] | and cannot be shown to be disjoint from it either.

341[error] | Therefore, reduction cannot advance to the remaining case

342[error] |

343[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS]

344[error] |--------------------------------------------------------------------------------------------------------------------

345[error] | Explanation (enabled by `-explain`)

346[error] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

347[error] |

348[error] | Tree:

349[error] |

350[error] | this.get[(l : String), KS, VS](l, TypedRecord.this.keys, TypedRecord.this.values)

351[error] |

352[error] | I tried to show that

353[error] | info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS]

354[error] | conforms to

355[error] | KS match {

356[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

357[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

358[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

359[error] | (VS match {

360[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

361[error] | })

362[error] | but none of the attempts shown below succeeded:

363[error] |

364[error] | ==> info.fingo.spata.schema.TypedRecord.Select[(l : String), KS, VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

365[error] | ==> KS match { case (l : String) *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[(l : String), t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

366[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[(l : String), Tuple, tv] }) <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

367[error] | ==> info.fingo.spata.schema.TypedRecord.SelectH[VS] <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

368[error] | ==> VS match { case h *: _ => h } <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] })

369[error] | ==> Any <: KS match { case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS] case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS] } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] | (VS match { case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv] }) = false

370[error] | ==> VS <: KS

371[error] | ==> VS <: Nothing in frozen constraint

372[error] | ==> Tuple <: Nothing in frozen constraint = false

373[error] | ==> Tuple <: Nothing in frozen constraint = false

374[error] | ==> Tuple <: KS

375[error] | ==> Tuple <: Nothing in frozen constraint = false

376[error] | ==> Tuple <: KS in frozen constraint

377[error] | ==> Tuple <: Nothing in frozen constraint = false

378[error] | ==> [_ <: Tuple] =>> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: [_ <: Tuple] =>> scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

379[error] | ==> scala.runtime.MatchCase[(l : String) *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]] <: scala.runtime.MatchCase[? <: String *: _, info.fingo.spata.schema.TypedRecord.SelectH[VS]]

380[error] | ==> ? <: String *: _ <: (l : String) *: _

381[error] | ==> Any <: (l : String) = false

382[error] |

383[error] | The tests were made under a constraint with:

384[error] | uninstantiated variables: B

385[error] | constrained types: [B](f: String => B): List[B], [B](f: String => B): List[B]

386[error] | bounds:

387[error] | B

388[error] | B :=

389[error] | KS match {

390[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

391[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

392[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

393[error] | (VS match {

394[error] | case _ *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

395[error] | })

396[error] | ordering:

397[error] | co-deps:

398[error] | contra-deps:

399[error] --------------------------------------------------------------------------------------------------------------------

400[error] -- [E172] Type Error: /build/repo/src/main/scala/info/fingo/spata/schema/TypedRecord.scala:94:46 -----------------------

401[error] 94 | m.fromProduct(Tuple.fromArray(vals.toArray))

402[error] | ^

403[error] | No ClassTag available for T

404[error] |

405[error] | where: T is a type variable with constraint >: KS match {

406[error] | case ? <: String *: _ => info.fingo.spata.schema.TypedRecord.SelectH[VS]

407[error] | case h *: t => info.fingo.spata.schema.TypedRecord.SelectT[String, t, VS]

408[error] | } <: info.fingo.spata.schema.TypedRecord.SelectH[VS] |

409[error] | (VS match {

410[error] | case _² *: tv => info.fingo.spata.schema.TypedRecord.Select[String, Tuple, tv]

411[error] | })

412[error] two errors found

413[error] (Compile / compileIncremental) Compilation failed

414

415************************

416Build summary:

417[{

418 "module": "spata",

419 "compile": {"status": "failed", "failureContext": {"type": "buildError", "reasons": ["Compilation failed"]}, "tookMs": 9167, "warnings": 0, "errors": 2, "sourceVersion": "3.5-migration"},

420 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

421 "test-compile": {"status": "skipped", "tookMs": 0, "warnings": 0, "errors": 0},

422 "test": {"status": "skipped", "tookMs": 0, "passed": 0, "failed": 0, "ignored": 0, "skipped": 0, "total": 0, "byFramework": []},

423 "publish": {"status": "skipped", "tookMs": 0},

424 "metadata": {

425 "crossScalaVersions": ["2.12.20"]

426}

427}]

428************************

429[error] Scala3CommunityBuild$ProjectBuildFailureException: 1 module(s) finished with failures: spata

430[error] (Global / runBuild) Scala3CommunityBuild$ProjectBuildFailureException: 1 module(s) finished with failures: spata

431[error] Total time: 18 s, completed Jan 13, 2026, 7:18:35 PM

432[0JBuild failed, not retrying.

Build Logs