books | Free Accounting Software

After some investigation, I found that there is a bug in react-router-dom version ^5.2.0. See this and this . I would suggest you to downgrade react-router-dom version to 4.10.1

The first quote is really saying the reference is not separable from the object.

... still seems to imply that "a reference is an object".

It really implies that a reference is a non-separable, non-first-class alias for an object, exactly as you first said.

The difficulty with these discussions is that the standardese meaning of "object" is already different from the meaning used in most less-formal contexts.

Let's start simple:

int a;

Would often be described as declaring an integer object a, right? It actually

1. declares an integer object
2. binds the name a to that object in the appropriate scope

Now, if we write

int &b = a;

we could say that b is the object in the same way as we could say that a is the object. Actually neither are correct, but given that informal text already uses the latter, it's no worse.

We should instead say that the name b refers to the same object as the name a. This is exactly consistent with calling it an alias, but informal or introductory texts would seem pretty cumbersome if they wrote "... the integer object referred to by the name a ..." everywhere instead of just "the integer a".

As for taking space in memory ... it depends. If I introduce 100 aliases for a single object inside a single function I'd be really surprised if the compiler didn't just collapse them (although of course they might still show up in debug symbols). No information is being lost here by eliding the redundant names.

If I pass an argument by reference to a non-inlined function, some actual information is being communicated, and that information must be stored somewhere.

Here since there is no func, so during the substitution of the template argument(s) in the return type of the function template, we get substitution failure and due to SFINAE this function template is not added to the set. In other words, it is ignored.

Thus the call timer(5); uses the ordinary function timer since it is the only viable option now that the function template has been ignored. Hence the program compiles and gives the output:

The first case is desugared like you expected:

You should have those two indexes to speed up your query :

Code readability, short-circuiting and it is not guaranteed that Ord will always outperform a || operand. Computer systems are more complicated than expected, even though they are man-made.

There was a case where a for loop with a much more complicated condition ran faster on an IBM. The CPU didn't cool and thus instructions were executed faster, that was a possible reason. What I am trying to say, focus on other areas to improve code than fighting small-cases which will differ depending on the CPU and the boolean evaluation (compiler optimizations).

Essentially, skipping over some stuff not relevant in this case, overload resolution is done to choose the user-defined conversion function to initialize the variable and (because there are no other differences between the conversion operators) the best viable one is chosen based on the rank of the standard conversion sequence required to convert the return value of to the variable's type.

The conversion int -> double is a floating-integral conversion, which has rank conversion.

The conversion float -> double is a floating-point promotion, which has rank promotion.

The rank promotion is better than the rank conversion, and so overload resolution will choose operator float as the best viable overload.

The conversion int -> long double is also a floating-integral conversion.

The conversion float -> long double is not a floating-point promotion (which only applies for conversion float -> double). It is instead a floating-point conversion which has rank conversion.

Both sequences now have the same standard conversion sequence rank and also none of the tie-breakers (which I won't go through) applies, so overload resolution is ambigious.

The conversion int -> bool is a boolean conversion which has rank conversion.

The conversion float -> bool is also a boolean conversion.

Therefore the same situation as above arises.

See https://en.cppreference.com/w/cpp/language/overload_resolution#Ranking_of_implicit_conversion_sequences and https://en.cppreference.com/w/cpp/language/implicit_conversion for a full list of the conversion categories and ranks.

Although it might seem that a conversion between floating-point types should be considered "better" than a conversion from integral to floating-point type, this is generally not the case.

TL;DR You are missing some resolvers. Your query resolvers are trying to do the job of the missing resolvers. Your resolvers must return data in the right shape.

In other words, your problems are with configuring Apollo Server's resolvers. Nothing Lambda-specific, as far as I can tell.

GraphQL doesn't know how to "resolve" an author's books, for instance. Add a Author {books(parent)} entry to Apollo Server's resolver map. The corresponding resolver function should return a list of book objects (i.e. [Books]), as your schema requires. Apollo's docs have a similar example you can adapt.

Here's a refactored author query, commented with the resolvers that will be called:

The pathInfo function returns all the path segments for a Request. Perhaps we could define a typeclass that, given a Servant API, produced a "parser" for the list of segments, whose result would be a formatted version of the list.

The parser type could be something like: