guards | 🛡 Comprehensive collection of type guards | Runtime Evironment library

TypeGuard annotations can be used to annotate subclasses of a class. If parameter types are specified for those classes, then MyPy will recognise the type narrowing operation successfully.

You can sum up the conditions and convert a Bool to an Int with fromEnum :: Enum a => a -> Bool:

Does Header guards prevent duplicate header files?

Yes. The first encountered inclusion will bring the content of the header to the translation unit, and the header guard causes successive inclusions to be empty which prevents the content of the header from being duplicated. This is exactly the reason why header guards are used.

or is this a bad practice and the extra header file should be deleted from main file?

No, the duplicate inclusion is not a bad practice. If the "main" header depends on any declaration from "some_header_file.h", then "main" absolutely should include "some_header_file.h" directly, whether another header - even one included by "main" - also includes it or not.

Relying on a transitive inclusion would generally be a bad practice - i.e. in this case it may be bad to rely on the detail that "foo.h" includes "some_header_file.h" when including "foo.h" into "main". Such assumptions often can cause programs to break unexpectedly when they are modified. In this case, if "foo.h" was modified to no longer depend on "some_header_file.h", and that inclusion was removed, then that change would suddenly cause the assumption to fail, and "some_header_file.h" would no longer be included into "main" as a result of change that didn't involve "main" at all. That would be bad.

After some digging I noticed that something is probably wrong with this line (x:xs) == []

(x:xs) == [] can never succeed. With (x:xs) you construct a list that contains at least one element: x is the first element, and xs is a (possibly empty) list of remaining elements, whereas [] is an empty list.

If you thus call go [], it will fail to pattern match with (x:xs), since the data constructor of an empty list is [], whereas the data constructor of a "cons" is (:). This will thus indeed raise a non-exhaustive pattern error.

You can you try this instead, I have just checked locally it works, just think it in a different way and you have your solution :)

So, this happens to be a "feature" of Typescript and how JavaScript object equality works in general. So in Nest's BaseExceptionFilter there's a check that exception instanceof HttpException, and normally, UnauthorizedException would be an instance of this, but because this is a library there's a few things that need to be considered.

1. All of the NestJS dependencies you're using have to be peerDependencies. This makes sure that when the library is installed, there's only one resulting package for the @nestjs/* package.

2. during local development, you'll need to take care to ensure that you're not resolving multiple instances of the same package (even if it's the exact same version, to JavaScript { hello: 'world' } === { hello: 'world' } // false). To take care of this, things like npm/yarn/pnpm link should not be used, but instead you should copy the dist and the package.json to the main application's node_modules/ directory.

   a. The other option is using a monorepo tool like Nest's monorepo approach or Nx which have single package version approaches, and use the paths of the libraries rather than internal links.

If you follow this, when your production application installs the npm library, everything will work without an issue. It's an annoyance for sure, but it's a side effect of how JavaScript works

Is it possible to pattern match by function in Haskell?

No. It is one of the consequences of Rice's theorem [wiki] that it is impossible to determine in general if two functions are equivalent. This thus means that it is possible to construct a function that can add two numbers together, but it is impossible for the compiler to proof that that function is equivalent to (+).

If we would use reference equality, then \x y -> x + y should not match with the pattern whereas passing (+) directly would match. This would be rather bizar. Imagine that you have a function f 0 = abs, or f 0 x = abs x. It would be quite strange that a (small) implementation detail of a function could determine the behavior of another function.

The function definition is hower correct (tested this on a GHC 9.0.1 and 8.6.5). It however will not check if the function is (+): you define a variable named (+) that you can use in the body of the function. You can use it as an infix operator, like x + y, or as (+) x y. But the function definition is identical to:

Autorelease Pools are a mechanism which comes from Objective-C for helping automate memory management and ensure that objects and resources are released "eventually", where that "eventually" comes when the pool is drained. i.e., an autorelease pool, once created on a thread, captures (retains) all objects which are -autoreleaseed while the pool is active — when the pool is drained, all of those objects are released. (Note that this is a Foundation feature in conjunction with the Objective-C runtime, and is not directly integrated with hardware: it's way, way higher-level than that.)

As a short-hand for managing autorelease pools directly (and avoiding creating NSAutoreleasePool instances directly), Objective-C introduced the @autoreleasepool language keyword, which effectively creates an autorelease pool at the beginning of the scope, and drains it at the end:

OK, I think I found a way...

First we create a "dummy" handler like this: