⚠ This page is served via a proxy. Original site: https://github.com
This service does not collect credentials or authentication data.
Skip to content

Drop deprecations #141

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mpilquist merged 1 commit into from
Jan 8, 2026
Merged

Drop deprecations #141

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
53 changes: 0 additions & 53 deletions core/shared/src/main/scala-2/org/typelevel/twiddles/TwiddleCompat.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -148,57 +148,4 @@ trait TwiddleCompat {
def hlistToTuple[L <: Tuple, T](l: L)(implicit
tupler: shapeless.ops.hlist.Tupler.Aux[L, T]
): T = l.tupled

@deprecated("use orgTypelevelTwiddleCompatToTupleOps", "0.9.1") def toTupleOps[T <: Tuple](
t: T
): TupleOps[T] = orgTypelevelTwiddleCompatToTupleOps(t)

// format: off
@deprecated("use orgTypelevelTwiddleCompatTuple2ToHList", "0.9.1") def tuple2ToHList[A, B](t: (A, B)): A *: B *: EmptyTuple = orgTypelevelTwiddleCompatTuple2ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple3ToHList", "0.9.1") def tuple3ToHList[A, B, C](t: (A, B, C)): A *: B *: C *: EmptyTuple = orgTypelevelTwiddleCompatTuple3ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple4ToHList", "0.9.1") def tuple4ToHList[A, B, C, D](t: (A, B, C, D)): A *: B *: C *: D *: EmptyTuple = orgTypelevelTwiddleCompatTuple4ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple5ToHList", "0.9.1") def tuple5ToHList[A, B, C, D, E](t: (A, B, C, D, E)): A *: B *: C *: D *: E *: EmptyTuple = orgTypelevelTwiddleCompatTuple5ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple6ToHList", "0.9.1") def tuple6ToHList[A, B, C, D, E, F](t: (A, B, C, D, E, F)): A *: B *: C *: D *: E *: F *: EmptyTuple = orgTypelevelTwiddleCompatTuple6ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple7ToHList", "0.9.1") def tuple7ToHList[A, B, C, D, E, F, G](t: (A, B, C, D, E, F, G)): A *: B *: C *: D *: E *: F *: G *: EmptyTuple = orgTypelevelTwiddleCompatTuple7ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple8ToHList", "0.9.1") def tuple8ToHList[A, B, C, D, E, F, G, H](t: (A, B, C, D, E, F, G, H)): A *: B *: C *: D *: E *: F *: G *: H *: EmptyTuple = orgTypelevelTwiddleCompatTuple8ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple9ToHList", "0.9.1") def tuple9ToHList[A, B, C, D, E, F, G, H, I](t: (A, B, C, D, E, F, G, H, I)): A *: B *: C *: D *: E *: F *: G *: H *: I *: EmptyTuple = orgTypelevelTwiddleCompatTuple9ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple10ToHList", "0.9.1") def tuple10ToHList[A, B, C, D, E, F, G, H, I, J](t: (A, B, C, D, E, F, G, H, I, J)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: EmptyTuple = orgTypelevelTwiddleCompatTuple10ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple11ToHList", "0.9.1") def tuple11ToHList[A, B, C, D, E, F, G, H, I, J, K](t: (A, B, C, D, E, F, G, H, I, J, K)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: EmptyTuple = orgTypelevelTwiddleCompatTuple11ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple12ToHList", "0.9.1") def tuple12ToHList[A, B, C, D, E, F, G, H, I, J, K, L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: EmptyTuple = orgTypelevelTwiddleCompatTuple12ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple13ToHList", "0.9.1") def tuple13ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M](t: (A, B, C, D, E, F, G, H, I, J, K, L, M)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: EmptyTuple = orgTypelevelTwiddleCompatTuple13ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple14ToHList", "0.9.1") def tuple14ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: EmptyTuple = orgTypelevelTwiddleCompatTuple14ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple15ToHList", "0.9.1") def tuple15ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: EmptyTuple = orgTypelevelTwiddleCompatTuple15ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple16ToHList", "0.9.1") def tuple16ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: EmptyTuple = orgTypelevelTwiddleCompatTuple16ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple17ToHList", "0.9.1") def tuple17ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: EmptyTuple = orgTypelevelTwiddleCompatTuple17ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple18ToHList", "0.9.1") def tuple18ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: EmptyTuple = orgTypelevelTwiddleCompatTuple18ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple19ToHList", "0.9.1") def tuple19ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: EmptyTuple = orgTypelevelTwiddleCompatTuple19ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple20ToHList", "0.9.1") def tuple20ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: EmptyTuple = orgTypelevelTwiddleCompatTuple20ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple21ToHList", "0.9.1") def tuple21ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: EmptyTuple = orgTypelevelTwiddleCompatTuple21ToHList(t)
@deprecated("use orgTypelevelTwiddleCompatTuple22ToHList", "0.9.1") def tuple22ToHList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): A *: B *: C *: D *: E *: F *: G *: H *: I *: J *: K *: L *: M *: N *: O *: P *: Q *: R *: S *: T *: U *: V *: EmptyTuple = orgTypelevelTwiddleCompatTuple22ToHList(t)

// format: off
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple0", "0.9.1") def hlistToTuple0[Z <: Tuple](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, Unit]): Unit = orgTypelevelTwiddleCompatHlistToTuple0(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple1", "0.9.1") def hlistToTuple1[Z <: Tuple, A](z: Z)(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Z, Tuple1[A]]): Tuple1[A] = orgTypelevelTwiddleCompatHlistToTuple1(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple2", "0.9.1") def hlistToTuple2[Z <: Tuple, A, B](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B)]): (A, B) = orgTypelevelTwiddleCompatHlistToTuple2(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple3", "0.9.1") def hlistToTuple3[Z <: Tuple, A, B, C](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C)]): (A, B, C) = orgTypelevelTwiddleCompatHlistToTuple3(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple4", "0.9.1") def hlistToTuple4[Z <: Tuple, A, B, C, D](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D)]): (A, B, C, D) = orgTypelevelTwiddleCompatHlistToTuple4(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple5", "0.9.1") def hlistToTuple5[Z <: Tuple, A, B, C, D, E](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E)]): (A, B, C, D, E) = orgTypelevelTwiddleCompatHlistToTuple5(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple6", "0.9.1") def hlistToTuple6[Z <: Tuple, A, B, C, D, E, F](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F)]): (A, B, C, D, E, F) = orgTypelevelTwiddleCompatHlistToTuple6(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple7", "0.9.1") def hlistToTuple7[Z <: Tuple, A, B, C, D, E, F, G](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G)]): (A, B, C, D, E, F, G) = orgTypelevelTwiddleCompatHlistToTuple7(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple8", "0.9.1") def hlistToTuple8[Z <: Tuple, A, B, C, D, E, F, G, H](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H)]): (A, B, C, D, E, F, G, H) = orgTypelevelTwiddleCompatHlistToTuple8(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple9", "0.9.1") def hlistToTuple9[Z <: Tuple, A, B, C, D, E, F, G, H, I](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I)]): (A, B, C, D, E, F, G, H, I) = orgTypelevelTwiddleCompatHlistToTuple9(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple10", "0.9.1") def hlistToTuple10[Z <: Tuple, A, B, C, D, E, F, G, H, I, J](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J)]): (A, B, C, D, E, F, G, H, I, J) = orgTypelevelTwiddleCompatHlistToTuple10(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple11", "0.9.1") def hlistToTuple11[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K)]): (A, B, C, D, E, F, G, H, I, J, K) = orgTypelevelTwiddleCompatHlistToTuple11(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple12", "0.9.1") def hlistToTuple12[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L)]): (A, B, C, D, E, F, G, H, I, J, K, L) = orgTypelevelTwiddleCompatHlistToTuple12(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple13", "0.9.1") def hlistToTuple13[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M)]): (A, B, C, D, E, F, G, H, I, J, K, L, M) = orgTypelevelTwiddleCompatHlistToTuple13(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple14", "0.9.1") def hlistToTuple14[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N) = orgTypelevelTwiddleCompatHlistToTuple14(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple15", "0.9.1") def hlistToTuple15[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) = orgTypelevelTwiddleCompatHlistToTuple15(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple16", "0.9.1") def hlistToTuple16[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) = orgTypelevelTwiddleCompatHlistToTuple16(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple17", "0.9.1") def hlistToTuple17[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) = orgTypelevelTwiddleCompatHlistToTuple17(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple18", "0.9.1") def hlistToTuple18[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) = orgTypelevelTwiddleCompatHlistToTuple18(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.9.1") def hlistToTuple19[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) = orgTypelevelTwiddleCompatHlistToTuple19(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.9.1") def hlistToTuple20[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) = orgTypelevelTwiddleCompatHlistToTuple20(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.9.1") def hlistToTuple21[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) = orgTypelevelTwiddleCompatHlistToTuple21(z)
@deprecated("use orgTypelevelTwiddleCompatHlistToTuple19", "0.9.1") def hlistToTuple22[Z <: Tuple, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](z: Z)(implicit tupler: Tupler.Aux[Z, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) = orgTypelevelTwiddleCompatHlistToTuple22(z)
// format: on
}