hash-set | : hash : Set with custom equality comparisons | Hashing library

You get error, because this expression (my-complex-object) calls function named my-complex-object. Use any from these definitions:

For this, you need to run the following commands,

If by "run a set of Bazel targets" you mean bazel run, you can use --build_tag_filters for this:

https://docs.bazel.build/versions/3.2.0/command-line-reference.html#flag--build_tag_filters

Note however that bazel run supports running only 1 executable target at a time.

If you want to run many binaries in a single call, you'll need to continue to pursue bazel query.

The attr() filter accepts a regular expression, so to get around the problem of tags being in arbitrary order, you can do something like:

bazel query "attr(tags, '\\bgood\\b', //...)"

(where \b is the word boundary matcher)

If you have multiple tags, you can use intersect:

bazel query "attr(tags, '\\bgood\\b', //...) intersect attr(tags, '\\balso-good\\b', //...)"

That will give you the list of targets to run, then you can do something like:

You are misdiagnosing the problem. k, v, l and w are in scope as type variables, but the types are incompatible (k can't unify with l and v can't unify with w). A different function that shows the type variables l and w working in the scope of the function-body, is this example:

Are the following two roughly the same?

Sure, but I'd be wary of learning Scheme or any Lisp by referring back to Python.

Note that R6RS Scheme has hash tables and hash table procedures as part of the Standard Libraries; this wasn't the case with R5RS Scheme. Consequently, earlier Scheme implementations usually had their own hash table implementations. Guile Scheme does support R6RS hash tables and procedures, but seems to maintain support for the older procedures, too. This is also the case for the Scheme that I am most familiar with, Chez Scheme. The Chez Scheme User's Guide says that the old-style procedures are included primarily for the sake of compatibility with older Chez Scheme implementations, but that support for them may be dropped in a future release. I don't know what Guile's stance is on this, but I would suggest using Standard Scheme procedures when possible for maximum portability and to guard against such future changes in your implementation.

Guile is up to v3.0.2 at the time of this writing; OP version is v2.0.9, which is currently about 5 years old as far as I can tell. Guile 2.0.14 supports R6RS hashtables, so I suspect that Guile 2.0.9 does as well. In any case, I will answer using R6RS Standard Scheme; adjusting to the old Guile implementation should be trivial if necessary.

The R6RS Standard Library does not have make-hash-table, but instead has make-hashtable, make-eq-hashtable, and make-eqv-hashtable. The make-hashtable procedure requires a procedure for testing equivalence of keys, while make-eq-hashtable tests for equivalence with eq?, and make-eqv-hashtable tests with eqv?.

Instead of hash-set!, the Standard Library has hashtable-set!, which takes the same arguments as OP has for hash-set!.

Instead of hash-ref, the Standard Library has hashtable-ref. This differs from OP hash-ref in that it requires a third argument to specify a default return value for when a key is not found.

Following in OP footsteps, a hash table can be created and queried:

Look right outside the cond:

Edit

I started riffing on an answer below, but it got me thinking "there's usually a built-in way to do this in Ruby/Rails", I would check out SimpleDelgator and if anyone wants to take a crack at using that to create a model like PersonAttributor < SimpleDelgator and do your transformations inside that, I'd upvote it.

Not sure if this is the direction you're looking to go but you could do something with JSON serialization. If you happen to be using Postgres you could use the JASONB column type and store the data as JSON that can be queried directly. But plain serialization could happen like:

A set is enough to model a one to many relationship. But it is not the only way to model such a relationship. You can also use a lost or a sortedset or even a stream to model such a relationship. The natural question is which one to use, and the answer is it depends.

If it is important to store messages in the order they were received, you would perhaps use a list. If you want to read most recent messages received by a user, a list would make sense.

On the other hand, if messages had a concept of likes or upvotes, and you want to find messages by the number of likes - a sorted set would make more sense.

You can define your own predicate to compare the keys, and ensure NaNs compare equal for this purpose. This can be supplied as the third parameter to the std::unordered_set class template.

See the definition of EqualPred below (code copied from question and modified), and its use in declaring the unordered_set variable. I took the default for the second parameter from the documentation at https://en.cppreference.com/w/cpp/container/unordered_set

Live demo: http://coliru.stacked-crooked.com/a/7085936431e6698f