D: Strange behaviour from std.container.BinaryHeap with custom function for comparison

Question

I've written the following code for a heap of Node*s, which are found in module node:

import std.exception, std.container;

public import node;

alias NodeArray = Array!(const (Node)*);
alias NodeHeap = BinaryHeap!(NodeArray, cmp_node_ptr);

auto make_heap() {
  return new NodeHeap(NodeArray(cast(const(Node)*)[]));
}

void insert(NodeHeap* heap, in Node* u) {
  enforce(heap && u);
  heap.insert(u);
}

pure bool cmp_node_ptr(in Node* a, in Node* b) {
  enforce(a && b);
  return (a.val > b.val);
}

I then tried running the following unit tests on it, where make_leaf returns a Node* initialized with the argument given:

unittest {
  auto u = make_leaf(10);
  auto heap = make_heap();
  insert(heap, u); //bad things happen here
  assert(heap.front == u);
  auto v = make_leaf(20);
  insert(heap, v);
  assert(heap.front == u); //assures heap property
}

The tests make it to the line I comment-marked, and then throw an enforcement error on the line enforce(a && b) in cmp_node_ptr. I'm totally lost as to why this is happening.

Answer 1

you are doing wrong thing in this operator:

NodeArray(cast(const(Node)*)[])

you obviously want to create empty NodeArray, but what you really got is NodeArray with one null item. NodeArray constructor takes list of values for new array as arguments, and you passing one "empty array" (which is essentially null), thus creating NodeArray with one null element.

the correct way is just:

NodeArray()

i.e.:

auto make_heap() {
  return new NodeHeap();
}

make this change and everything will be fine.

p.s. it seems that D notation for multiple arguments of type U (U[] values...) made you think that constructor accepts another array as initialiser.

p.p.s. sorry, fixed make_heap() code: accidentally forgot to write "NodeArray()" in it. and edited it again, as empty NodeArray() call is not necessary there. double fault!