История изменений
Исправление Miguel, (текущая версия) :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
}
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (heap->rest) {
return eval(heap->head) + heapSumInt(heap->rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
return eval(heap->head)
}
}
int heapSum(Heap<int> *heap) {
return healSumInt(heap, identity)
}
Исправление Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
}
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (heap->rest) {
return eval(heap->head) + heapSumInt(heap->rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
return eval(heap->head)
}
}
int heapSum(Heap<int> *heap) {
return healSumInt(heap, identity)
}
Исправление Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
}
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (rest) {
return eval(heap->head) + heapSumInt(heap->rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
return eval(heap->head)
}
}
int heapSum(Heap<int> *heap) {
return healSumInt(heap, identity)
}
Исправление Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
}
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (rest) {
eval(heap->head) + heapSumInt(heap->rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
eval(heap->head)
}
}
Исправление Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
}
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (rest) {
eval(heap->head) + heapSumInt(heap->rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
eval(heap->head)
}
}
Исправление Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
}
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt(Heap<T> *heap, std::function<int, T> eval) {
if (rest) {
eval(heap -> head) + heapSumInt(heap -> rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
eval(heap -> head)
}
}
Исходная версия Miguel, :
Дженерики, которые позволяют заводить неограниченное количество типов, в зависимости от рантайм-условий. Ну, грубо (пример выморочный)
case class Heap[T](head: T, rest: Option[Binary[(T,T)]])
def heapSumInt[T](heap: Heap[T], eval: T => Int): Int = rest match {
case None => eval(bit)
case Some(subHeap) => eval(bit) + heapSumInt(subHeap, {case (fst, snd) => eval(fst) + eval(snd)})
def heapSum(heap: Heap[Int]): Int = heapSumInt(heap, (n => n))
}
Попробуй переписать на кресты. Будет что-то вроде (сорри за ашипки):
template<typename T> class Heap {
T head;
Heap<std::pair<T, T>> *rest;
}
template<T> int heapSumInt<T>(Heap<T> *heap, std::function<int, T> eval) {
if (rest) {
eval(heap -> head) + heapSumInt(heap -> rest, как там блин эту функцию написать, которая применит eval к обеим частям пары и сложит)
} else {
eval(heap -> head)
}
}