Build Logs

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

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

213[warn] | ^

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

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

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

217[warn] | ^

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

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

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

221[warn] | ^

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

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

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

225[warn] | ^

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

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

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

229[warn] | ^

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

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

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

233[warn] | ^

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

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

236[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 {

237[warn] | ^

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

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

240[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 {

241[warn] | ^

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

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

244[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 {

245[warn] | ^

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

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

248[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 {

249[warn] | ^

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

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

252[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 {

253[warn] | ^

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

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

256[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 {

257[warn] | ^

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

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

260[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 {

261[warn] | ^

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

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

264[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 {

265[warn] | ^

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

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

268[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 {

269[warn] | ^

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

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

272[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 {

273[warn] | ^

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

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

276[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 {

277[warn] | ^

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

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

280[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 {

281[warn] | ^

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

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

284[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 {

285[warn] | ^

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

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

288[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 {

289[warn] | ^

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

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

292[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 {

293[warn] | ^

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

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

296[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 {

297[warn] | ^

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

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

300[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 {

301[warn] | ^

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

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

304[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 {

305[warn] | ^

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

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

308[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 {

309[warn] | ^

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

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

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

313[warn] | ^

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

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

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

317[warn] | ^

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

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

320[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 {

321[warn] | ^

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

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

324[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 {

325[warn] | ^

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

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

328[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 {

329[warn] | ^

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

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

332[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 {

333[warn] | ^

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

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

336[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 {

337[warn] | ^

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

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

340[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 {

341[warn] | ^

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

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

344[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 {

345[warn] | ^

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

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

348[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 {

349[warn] | ^

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

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

352[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 {

353[warn] | ^

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

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

356[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 {

357[warn] | ^

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

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

360[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 {

361[warn] | ^

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

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

364[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 {

365[warn] | ^

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

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

368[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 {

369[warn] | ^

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

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

372[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 {

373[warn] | ^

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

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

376[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 {

377[warn] | ^

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

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

380[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 {

381[warn] | ^

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

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

384[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 {

385[warn] | ^

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

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

388[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 {

389[warn] | ^

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

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

392[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 {

393[warn] | ^

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

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

396[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 {

397[warn] | ^

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

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

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

401[warn] | ^

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

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

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

405[warn] | ^

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

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

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

409[warn] | ^

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

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

412[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 {

413[warn] | ^

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

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

416[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 {

417[warn] | ^

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

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

420[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 {

421[warn] | ^

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

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

424[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 {

425[warn] | ^

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

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

428[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 {

429[warn] | ^

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

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

432[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 {

433[warn] | ^

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

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

436[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 {

437[warn] | ^

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

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

440[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 {

441[warn] | ^

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

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

444[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 {

445[warn] | ^

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

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

448[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 {

449[warn] | ^

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

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

452[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 {

453[warn] | ^

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

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

456[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 {

457[warn] | ^

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

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

460[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 {

461[warn] | ^

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

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

464[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 {

465[warn] | ^

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

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

468[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 {

469[warn] | ^

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

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

472[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 {

473[warn] | ^

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

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

476[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 {

477[warn] | ^

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

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

480[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 {

481[warn] | ^

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

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

484[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 {

485[warn] | ^

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

487[warn] 69 warnings found