LINUX.ORG.RU

История изменений

Исправление 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)
  }
}