Build Logs

210[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:28:5

211[warn] 28 | def p(): Parser[Unit] = Parser.string(sc.parts.mkString)

212[warn] | ^

213[warn] | Line is indented too far to the left, or a `}` is missing

214[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:29:5

215[warn] 29 | def p0(): Parser0[Unit] = Parser.string0(sc.parts.mkString)

216[warn] | ^

217[warn] | Line is indented too far to the left, or a `}` is missing

218[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:30:5

219[warn] 30 | def pm(): Parser[Unit] = Parser.string(sc.parts.mkString)

220[warn] | ^

221[warn] | Line is indented too far to the left, or a `}` is missing

222[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:34:2

223[warn] 34 | def p[A](pa: Parser[A]): Parser[(A)] = (nonEmptyParts: @scala.unchecked) match {

224[warn] | ^

225[warn] | Line is indented too far to the left, or a `}` is missing

226[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:40:2

227[warn] 40 | def p[A, B](pa: Parser[A], pb: Parser[B]): Parser[(A, B)] = (nonEmptyParts: @scala.unchecked) match {

228[warn] | ^

229[warn] | Line is indented too far to the left, or a `}` is missing

230[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:46:2

231[warn] 46 | def p[A, B, C](pa: Parser[A], pb: Parser[B], pc: Parser[C]): Parser[(A, B, C)] = (nonEmptyParts: @scala.unchecked) match {

232[warn] | ^

233[warn] | Line is indented too far to the left, or a `}` is missing

234[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:52:2

235[warn] 52 | def p[A, B, C, D](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D]): Parser[(A, B, C, D)] = (nonEmptyParts: @scala.unchecked) match {

236[warn] | ^

237[warn] | Line is indented too far to the left, or a `}` is missing

238[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:58:2

239[warn] 58 | def p[A, B, C, D, E](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E]): Parser[(A, B, C, D, E)] = (nonEmptyParts: @scala.unchecked) match {

240[warn] | ^

241[warn] | Line is indented too far to the left, or a `}` is missing

242[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:64:2

243[warn] 64 | def p[A, B, C, D, E, F](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F]): Parser[(A, B, C, D, E, F)] = (nonEmptyParts: @scala.unchecked) match {

244[warn] | ^

245[warn] | Line is indented too far to the left, or a `}` is missing

246[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:70:2

247[warn] 70 | def p[A, B, C, D, E, F, G](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G]): Parser[(A, B, C, D, E, F, G)] = (nonEmptyParts: @scala.unchecked) match {

248[warn] | ^

249[warn] | Line is indented too far to the left, or a `}` is missing

250[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:76:2

251[warn] 76 | def p[A, B, C, D, E, F, G, H](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H]): Parser[(A, B, C, D, E, F, G, H)] = (nonEmptyParts: @scala.unchecked) match {

252[warn] | ^

253[warn] | Line is indented too far to the left, or a `}` is missing

254[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:82:2

255[warn] 82 | def p[A, B, C, D, E, F, G, H, I](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I]): Parser[(A, B, C, D, E, F, G, H, I)] = (nonEmptyParts: @scala.unchecked) match {

256[warn] | ^

257[warn] | Line is indented too far to the left, or a `}` is missing

258[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:88:2

259[warn] 88 | def p[A, B, C, D, E, F, G, H, I, J](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J]): Parser[(A, B, C, D, E, F, G, H, I, J)] = (nonEmptyParts: @scala.unchecked) match {

260[warn] | ^

261[warn] | Line is indented too far to the left, or a `}` is missing

262[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:94:2

263[warn] 94 | def p[A, B, C, D, E, F, G, H, I, J, K](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K]): Parser[(A, B, C, D, E, F, G, H, I, J, K)] = (nonEmptyParts: @scala.unchecked) match {

264[warn] | ^

265[warn] | Line is indented too far to the left, or a `}` is missing

266[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:100:2

267[warn] 100 | def p[A, B, C, D, E, F, G, H, I, J, K, L](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L)] = (nonEmptyParts: @scala.unchecked) match {

268[warn] | ^

269[warn] | Line is indented too far to the left, or a `}` is missing

270[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:106:2

271[warn] 106 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = (nonEmptyParts: @scala.unchecked) match {

272[warn] | ^

273[warn] | Line is indented too far to the left, or a `}` is missing

274[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:112:2

275[warn] 112 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = (nonEmptyParts: @scala.unchecked) match {

276[warn] | ^

277[warn] | Line is indented too far to the left, or a `}` is missing

278[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:118:2

279[warn] 118 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = (nonEmptyParts: @scala.unchecked) match {

280[warn] | ^

281[warn] | Line is indented too far to the left, or a `}` is missing

282[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:124:2

283[warn] 124 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = (nonEmptyParts: @scala.unchecked) match {

284[warn] | ^

285[warn] | Line is indented too far to the left, or a `}` is missing

286[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:130:2

287[warn] 130 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = (nonEmptyParts: @scala.unchecked) match {

288[warn] | ^

289[warn] | Line is indented too far to the left, or a `}` is missing

290[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:136:2

291[warn] 136 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q], pr: Parser[R]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = (nonEmptyParts: @scala.unchecked) match {

292[warn] | ^

293[warn] | Line is indented too far to the left, or a `}` is missing

294[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:142:2

295[warn] 142 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q], pr: Parser[R], ps: Parser[S]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = (nonEmptyParts: @scala.unchecked) match {

296[warn] | ^

297[warn] | Line is indented too far to the left, or a `}` is missing

298[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:148:2

299[warn] 148 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q], pr: Parser[R], ps: Parser[S], pt: Parser[T]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = (nonEmptyParts: @scala.unchecked) match {

300[warn] | ^

301[warn] | Line is indented too far to the left, or a `}` is missing

302[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:154:2

303[warn] 154 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q], pr: Parser[R], ps: Parser[S], pt: Parser[T], pu: Parser[U]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = (nonEmptyParts: @scala.unchecked) match {

304[warn] | ^

305[warn] | Line is indented too far to the left, or a `}` is missing

306[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:160:2

307[warn] 160 | def p[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](pa: Parser[A], pb: Parser[B], pc: Parser[C], pd: Parser[D], pe: Parser[E], pf: Parser[F], pg: Parser[G], ph: Parser[H], pi: Parser[I], pj: Parser[J], pk: Parser[K], pl: Parser[L], pm: Parser[M], pn: Parser[N], po: Parser[O], pp: Parser[P], pq: Parser[Q], pr: Parser[R], ps: Parser[S], pt: Parser[T], pu: Parser[U], pv: Parser[V]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = (nonEmptyParts: @scala.unchecked) match {

308[warn] | ^

309[warn] | Line is indented too far to the left, or a `}` is missing

310[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:166:2

311[warn] 166 | def p0[A](pa: Parser0[A]): Parser0[(A)] = (sc.parts.toList: @scala.unchecked) match {

312[warn] | ^

313[warn] | Line is indented too far to the left, or a `}` is missing

314[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:172:2

315[warn] 172 | def p0[A, B](pa: Parser0[A], pb: Parser0[B]): Parser0[(A, B)] = (sc.parts.toList: @scala.unchecked) match {

316[warn] | ^

317[warn] | Line is indented too far to the left, or a `}` is missing

318[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:178:2

319[warn] 178 | def p0[A, B, C](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C]): Parser0[(A, B, C)] = (sc.parts.toList: @scala.unchecked) match {

320[warn] | ^

321[warn] | Line is indented too far to the left, or a `}` is missing

322[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:184:2

323[warn] 184 | def p0[A, B, C, D](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D]): Parser0[(A, B, C, D)] = (sc.parts.toList: @scala.unchecked) match {

324[warn] | ^

325[warn] | Line is indented too far to the left, or a `}` is missing

326[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:190:2

327[warn] 190 | def p0[A, B, C, D, E](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E]): Parser0[(A, B, C, D, E)] = (sc.parts.toList: @scala.unchecked) match {

328[warn] | ^

329[warn] | Line is indented too far to the left, or a `}` is missing

330[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:196:2

331[warn] 196 | def p0[A, B, C, D, E, F](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F]): Parser0[(A, B, C, D, E, F)] = (sc.parts.toList: @scala.unchecked) match {

332[warn] | ^

333[warn] | Line is indented too far to the left, or a `}` is missing

334[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:202:2

335[warn] 202 | def p0[A, B, C, D, E, F, G](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G]): Parser0[(A, B, C, D, E, F, G)] = (sc.parts.toList: @scala.unchecked) match {

336[warn] | ^

337[warn] | Line is indented too far to the left, or a `}` is missing

338[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:208:2

339[warn] 208 | def p0[A, B, C, D, E, F, G, H](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H]): Parser0[(A, B, C, D, E, F, G, H)] = (sc.parts.toList: @scala.unchecked) match {

340[warn] | ^

341[warn] | Line is indented too far to the left, or a `}` is missing

342[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:214:2

343[warn] 214 | def p0[A, B, C, D, E, F, G, H, I](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I]): Parser0[(A, B, C, D, E, F, G, H, I)] = (sc.parts.toList: @scala.unchecked) match {

344[warn] | ^

345[warn] | Line is indented too far to the left, or a `}` is missing

346[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:220:2

347[warn] 220 | def p0[A, B, C, D, E, F, G, H, I, J](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J]): Parser0[(A, B, C, D, E, F, G, H, I, J)] = (sc.parts.toList: @scala.unchecked) match {

348[warn] | ^

349[warn] | Line is indented too far to the left, or a `}` is missing

350[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:226:2

351[warn] 226 | def p0[A, B, C, D, E, F, G, H, I, J, K](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K]): Parser0[(A, B, C, D, E, F, G, H, I, J, K)] = (sc.parts.toList: @scala.unchecked) match {

352[warn] | ^

353[warn] | Line is indented too far to the left, or a `}` is missing

354[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:232:2

355[warn] 232 | def p0[A, B, C, D, E, F, G, H, I, J, K, L](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L)] = (sc.parts.toList: @scala.unchecked) match {

356[warn] | ^

357[warn] | Line is indented too far to the left, or a `}` is missing

358[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:238:2

359[warn] 238 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = (sc.parts.toList: @scala.unchecked) match {

360[warn] | ^

361[warn] | Line is indented too far to the left, or a `}` is missing

362[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:244:2

363[warn] 244 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = (sc.parts.toList: @scala.unchecked) match {

364[warn] | ^

365[warn] | Line is indented too far to the left, or a `}` is missing

366[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:250:2

367[warn] 250 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = (sc.parts.toList: @scala.unchecked) match {

368[warn] | ^

369[warn] | Line is indented too far to the left, or a `}` is missing

370[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:256:2

371[warn] 256 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = (sc.parts.toList: @scala.unchecked) match {

372[warn] | ^

373[warn] | Line is indented too far to the left, or a `}` is missing

374[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:262:2

375[warn] 262 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = (sc.parts.toList: @scala.unchecked) match {

376[warn] | ^

377[warn] | Line is indented too far to the left, or a `}` is missing

378[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:268:2

379[warn] 268 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = (sc.parts.toList: @scala.unchecked) match {

380[warn] | ^

381[warn] | Line is indented too far to the left, or a `}` is missing

382[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:274:2

383[warn] 274 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = (sc.parts.toList: @scala.unchecked) match {

384[warn] | ^

385[warn] | Line is indented too far to the left, or a `}` is missing

386[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:280:2

387[warn] 280 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = (sc.parts.toList: @scala.unchecked) match {

388[warn] | ^

389[warn] | Line is indented too far to the left, or a `}` is missing

390[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:286:2

391[warn] 286 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T], pu: Parser0[U]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = (sc.parts.toList: @scala.unchecked) match {

392[warn] | ^

393[warn] | Line is indented too far to the left, or a `}` is missing

394[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:292:2

395[warn] 292 | def p0[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](pa: Parser0[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T], pu: Parser0[U], pv: Parser0[V]): Parser0[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = (sc.parts.toList: @scala.unchecked) match {

396[warn] | ^

397[warn] | Line is indented too far to the left, or a `}` is missing

398[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:298:2

399[warn] 298 | def pm[A](pa: Parser[A]): Parser[(A)] = (nonEmptyParts: @scala.unchecked) match {

400[warn] | ^

401[warn] | Line is indented too far to the left, or a `}` is missing

402[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:304:2

403[warn] 304 | def pm[A, B](pa: Parser[A], pb: Parser0[B]): Parser[(A, B)] = (partsSafeHead: @scala.unchecked) match {

404[warn] | ^

405[warn] | Line is indented too far to the left, or a `}` is missing

406[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:312:2

407[warn] 312 | def pm[A, B, C](pa: Parser[A], pb: Parser0[B], pc: Parser0[C]): Parser[(A, B, C)] = (partsSafeHead: @scala.unchecked) match {

408[warn] | ^

409[warn] | Line is indented too far to the left, or a `}` is missing

410[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:320:2

411[warn] 320 | def pm[A, B, C, D](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D]): Parser[(A, B, C, D)] = (partsSafeHead: @scala.unchecked) match {

412[warn] | ^

413[warn] | Line is indented too far to the left, or a `}` is missing

414[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:328:2

415[warn] 328 | def pm[A, B, C, D, E](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E]): Parser[(A, B, C, D, E)] = (partsSafeHead: @scala.unchecked) match {

416[warn] | ^

417[warn] | Line is indented too far to the left, or a `}` is missing

418[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:336:2

419[warn] 336 | def pm[A, B, C, D, E, F](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F]): Parser[(A, B, C, D, E, F)] = (partsSafeHead: @scala.unchecked) match {

420[warn] | ^

421[warn] | Line is indented too far to the left, or a `}` is missing

422[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:344:2

423[warn] 344 | def pm[A, B, C, D, E, F, G](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G]): Parser[(A, B, C, D, E, F, G)] = (partsSafeHead: @scala.unchecked) match {

424[warn] | ^

425[warn] | Line is indented too far to the left, or a `}` is missing

426[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:352:2

427[warn] 352 | def pm[A, B, C, D, E, F, G, H](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H]): Parser[(A, B, C, D, E, F, G, H)] = (partsSafeHead: @scala.unchecked) match {

428[warn] | ^

429[warn] | Line is indented too far to the left, or a `}` is missing

430[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:360:2

431[warn] 360 | def pm[A, B, C, D, E, F, G, H, I](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I]): Parser[(A, B, C, D, E, F, G, H, I)] = (partsSafeHead: @scala.unchecked) match {

432[warn] | ^

433[warn] | Line is indented too far to the left, or a `}` is missing

434[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:368:2

435[warn] 368 | def pm[A, B, C, D, E, F, G, H, I, J](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J]): Parser[(A, B, C, D, E, F, G, H, I, J)] = (partsSafeHead: @scala.unchecked) match {

436[warn] | ^

437[warn] | Line is indented too far to the left, or a `}` is missing

438[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:376:2

439[warn] 376 | def pm[A, B, C, D, E, F, G, H, I, J, K](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K]): Parser[(A, B, C, D, E, F, G, H, I, J, K)] = (partsSafeHead: @scala.unchecked) match {

440[warn] | ^

441[warn] | Line is indented too far to the left, or a `}` is missing

442[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:384:2

443[warn] 384 | def pm[A, B, C, D, E, F, G, H, I, J, K, L](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L)] = (partsSafeHead: @scala.unchecked) match {

444[warn] | ^

445[warn] | Line is indented too far to the left, or a `}` is missing

446[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:392:2

447[warn] 392 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = (partsSafeHead: @scala.unchecked) match {

448[warn] | ^

449[warn] | Line is indented too far to the left, or a `}` is missing

450[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:400:2

451[warn] 400 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = (partsSafeHead: @scala.unchecked) match {

452[warn] | ^

453[warn] | Line is indented too far to the left, or a `}` is missing

454[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:408:2

455[warn] 408 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = (partsSafeHead: @scala.unchecked) match {

456[warn] | ^

457[warn] | Line is indented too far to the left, or a `}` is missing

458[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:416:2

459[warn] 416 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = (partsSafeHead: @scala.unchecked) match {

460[warn] | ^

461[warn] | Line is indented too far to the left, or a `}` is missing

462[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:424:2

463[warn] 424 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = (partsSafeHead: @scala.unchecked) match {

464[warn] | ^

465[warn] | Line is indented too far to the left, or a `}` is missing

466[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:432:2

467[warn] 432 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = (partsSafeHead: @scala.unchecked) match {

468[warn] | ^

469[warn] | Line is indented too far to the left, or a `}` is missing

470[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:440:2

471[warn] 440 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = (partsSafeHead: @scala.unchecked) match {

472[warn] | ^

473[warn] | Line is indented too far to the left, or a `}` is missing

474[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:448:2

475[warn] 448 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = (partsSafeHead: @scala.unchecked) match {

476[warn] | ^

477[warn] | Line is indented too far to the left, or a `}` is missing

478[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:456:2

479[warn] 456 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T], pu: Parser0[U]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = (partsSafeHead: @scala.unchecked) match {

480[warn] | ^

481[warn] | Line is indented too far to the left, or a `}` is missing

482[warn] -- Warning: /build/repo/core/src/main/scala/net/andimiller/cats/parse/interpolator/package.scala:464:2

483[warn] 464 | def pm[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](pa: Parser[A], pb: Parser0[B], pc: Parser0[C], pd: Parser0[D], pe: Parser0[E], pf: Parser0[F], pg: Parser0[G], ph: Parser0[H], pi: Parser0[I], pj: Parser0[J], pk: Parser0[K], pl: Parser0[L], pm: Parser0[M], pn: Parser0[N], po: Parser0[O], pp: Parser0[P], pq: Parser0[Q], pr: Parser0[R], ps: Parser0[S], pt: Parser0[T], pu: Parser0[U], pv: Parser0[V]): Parser[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = (partsSafeHead: @scala.unchecked) match {

484[warn] | ^

485[warn] | Line is indented too far to the left, or a `}` is missing

486[warn] 69 warnings found