मैं Project Euler Problem #2 करने के लिए मेरे निराकार समाधान पर शुरू कर दिया है।स्काला निराकार कोड 2
मैं इस कोड के साथ Nth भी एक अप करने के लिए एक साथ सभी भी fibs जोड़ सकते हैं:
import shapeless._, nat._, ops.nat.Sum
trait Fibonacci[N <: Nat] { type Out <: Nat }
object Fibonacci {
type Aux[N <: Nat, Out0 <: Nat] = Fibonacci[N] { type Out = Out0 }
def apply[N <: Nat](i: Nat)(implicit fib: Aux[i.N, N], n: Witness.Aux[N]):N = n.value
implicit val fib0 = new Fibonacci[_0] { type Out = _2 }
implicit val fib1 = new Fibonacci[_1] { type Out = _3 }
implicit def fibN[I <: Nat, L <: Nat, M <: Nat](implicit l: Aux[I, L],
m: Aux[Succ[I], M],
sum: Sum[L, M]) =
new Fibonacci[Succ[Succ[I]]] { type Out = sum.Out }
}
trait Fibs[N <: Nat] { type Out <: Nat }
object Fibs {
type Aux[N <: Nat, Out0 <: Nat] = Fibs[N] { type Out = Out0 }
def apply[N <: Nat](i: Nat)(implicit fibs: Aux[i.N, N], n: Witness.Aux[N]):N = n.value
implicit def fibs0(implicit f: Fibonacci[_0]) = new Fibs[_0] { type Out = f.Out }
implicit def fibsN[N <: Nat, R <: Nat, Z <: Nat](implicit fib: Fibonacci.Aux[Succ[Succ[Succ[N]]], R],
fibs: Aux[N, Z],
sum: Sum[R, Z]) =
new Fibs[Succ[N]] {
type Out = sum.Out
}
}
अब मैं कर सकते हैं:
val (evenFibs0, evenFibs1) = (Fibs(0), Fibs(1))
typed[_2](evenFibs0)
typed[_10](evenFibs1)
यह कैसे मैं सभी भी fibs मिलता है: मैं अनुक्रम 2, 3, ... के साथ शुरू करता हूं, और मैं हर तीसरे फिबोनाची संख्या को जोड़ता हूं।
अब, मैं अटक कर रहा हूँ। मैं takeWhile के समान कार्यक्षमता करना चाहते हैं, तो मैं एक समारोह है कि एक limit स्वीकार करता है और मेरी भी fibs जिसका शर्तों कि सीमा से अधिक नहीं है का योग देता है लिख सकते हैं। कोई विचार?
यहाँ मैं अब तक क्या कोशिश की है के लिए मेरे प्रयास है:
trait EvenFibsWithLimit[N <: Nat, M <: Nat] { type Out <: Nat }
trait LowPriorityFibs3 {
type Aux[N <: Nat, M <: Nat, Out0 <: Nat] = EvenFibsWithLimit[N, M] { type Out = Out0 }
implicit def fibs0[M <: Nat] = new EvenFibsWithLimit[_0, M] { type Out = _0 }
implicit def fibsGT[N <: Nat, M <: Nat, O <: Nat](implicit f: EvenFibsWithLimit[N, M],
fib: Fibs.Aux[N, O],
l: ops.nat.LT[M, O]) = f
}
object EvenFibsWithLimit extends LowPriorityFibs3 {
def apply[N <: Nat, O <: Nat](limit: Nat)(implicit fibs: Aux[N, limit.N, O],
o: Witness.Aux[O]): O = o.value
implicit def fibsN[N <: Nat, M <: Nat, O <: Nat](implicit f: EvenFibsWithLimit[N, M],
f2: Fibs.Aux[Succ[N], O],
d: ops.nat.Diff[M, O]) =
new EvenFibsWithLimit[Succ[N], d.Out] {
type Out = O
}
}
विचार रिकर्सिवली उत्पादन द्वारा सीमा घटाने के लिए जब तक उत्पादन सीमा से कम है था। मैं निश्चित रूप से कुछ गंध कर सकता हूँ। मुझे नहीं लगता कि मुझे Diff बिल्कुल चाहिए .. मैंने कुछ अन्य बदलावों की भी कोशिश की है, लेकिन मैं अटक गया हूं।
मैं शायद सोच रहा था मैं अपने Fibs के HList निर्माण कर सकते हैं, और एक विधेय typeclass साथ Selector का प्रयोग कर एक takeWhile अनुकरण करने के लिए: जब मैं संकलन, मैं त्रुटि diverging implicit expansion for fibsN.
संपादित मिलता है। विचार?
अच्छी तकनीक। मैं अब चीजों की लटकना शुरू कर रहा हूं, धन्यवाद। – beefyhalo