permit | A laravel package to handle user authorization and ACL | Authorization library

Since August 13, 2021, GitHub does not support authentication via HTTPS with your GitHub account password for security reasons anymore. Instead, in Eclipse, when pushing to a GitHub repository or when fetching from a private repository, you will get a git-upload-pack not permitted on 'https://github.com...' error.

As solution, use either

• a GitHub specific Personal access tokens as password instead of your previously used GitHub account password or
• SSH with an SSH key of which the private and public key is on your local machine and configured in Eclipse and the public key is uploaded to your GitHub account instead.

1. Go to your GitHub account to Settings > Developer settings > Personal access tokens website:
   1. Click the Generate new token button in the upper right
      • Enter a Note, e.g. GitHub repo token
      • Choose Expiration, e.g. No expiration
      • Tick the checkbox repo
   2. Click the Generate token button at the bottom
   3. Copy the generated token to the clipboard
2. In Eclipse, in the Git Repositories view:
   1. Right-click the Remotes sub-node for GitHub (origin or the name you have chosen when you have cloned the repository) and choose Configure Push...
   2. Click the Change... button to change the URI in the upper right
   3. Replace the password with with the copied generated GitHub token
   4. Click Finish and Save to apply the changes

1. Create an SSH key (skip this step when you already have one):
   1. In Eclipse, in the preferences General > Network Connections > SSH2 tab Key Management hit the Generate RSA Key... button
   2. Hit Save Private Key... and choose a location, preferably the subfolder .ssh of your user home directory
2. Upload public key to your GitHub account:
   1. For a new created key, copy the string shown in the Key Management tab to the clipboard; for an existing key add it in the preferences General > Network Connections > SSH2 tab General and copy the content of the public key file .pub
   2. Go to your GitHub account settings to the SSH and GPG keys section and hit the New SSH key button
   3. Paste the copied public key into the Key field
3. Change HTTPS to SSH URLs of already cloned repositories:
   1. In Eclipse, in the Git Repositories view right-click the repository and choose Properties and click the Open button
   2. In the text editor of the config file change the remote URL as follows:
      
      HTTPS (old; does not work for push anymore):
      

You have to convert v back to *M again.

Just to add a little more color as to the why:

Byrefs and byref-like types fly in the face of functional-first programming.

These types are required to have their entire lifetime on the stack, and come with some compiler analysis that allow the runtime to elide some checks. That's great for performance.

When a function is made first-class, it involves a heap allocation. It's an object with an Invoke method on it, basically. In the F# compiler there are several optimizations that attempt to convert an F# function into just a static method (and most F# function declarations are like this), but there are many circumstances where they're emitted as objects on the heap (some you can predict, some you can't). That means several things:

• You can't pass a function around that takes a byref or byref-like type as a parameter
• You can't use a byref or byref-like type in a lambda
• You can't use a byref or byref-like type in an inner function

There are some cases where this would technically be possible, but there's nothing in source code that would indicate why it's possible in some cases but not others. The reason would simply be "because the compiler needs to emit this function as an object" and that is entirely unpredictable and non-uniform. One proposed suggestion would help with this, but it's closed in favor of tweaks in the compiler and like this suggestion, which is estimated to probably not be too bad from a predictability standpoint.

Now the |> case is more interesting, as are several other functions that are declared inline. The |> operator is quite literally defined to take in a higher-order function as a parameter, so naturally it shouldn't be supported. But because it's defined as inline, it could actually work since it's just an optimization. However, this may also require that you can only use it in the context of other inline functions. You may not be able to pipe into any arbitrary function.

That's why this is not a bug, but a by-design behavior that will take some serious consideration into enhancing, should it be implemented: https://github.com/fsharp/fslang-suggestions/issues/688

You need to specify that it's a digest:

Solution was adding --verbose mode and see the logs. The problem was that azure didn't support node version 15. Downgraded nodejs to version 13.12.0 and it worked.

You don't see a list of Haskell built-in operators for the same reason you don't see a list of all built-in functions. They're everywhere. Some are in Prelude, some are in Control.Monad, etc., etc. Operators aren't special in Haskell; they're ordinary functions with neat syntax. And Haskellers are generally pretty operator-happy in general. Spend any time inside your favorite lens library and you'll find plenty of amusing-looking operators.

In terms of (#), it might be best to avoid. I don't know of any built-in operators called that, but # can be a bit special when it comes to parsing. Specifically, a compiler extension enables # at the end of ordinary identifiers, and GHC defines a lot of built-in (primitive) types following this practice. For instance, Int is the usual (boxed) integer type, whereas Int# is a primitive integer. Most people don't need to interface with this directly, but it is a use that # has in Haskell that would be confused slightly by the addition of your operator.

Your (#) operator is called (>>>) in Haskell, and it works on all Category instances, including functions. Its companion is (<<<), the generalization of (.) to all Category instances. If three characters is too long for you, I've seen it called (|>) in some other languages, but Haskell already uses that operator for something else. If you're not using Data.Sequence, you could use that operator. But personally, I'd just go with (>>>). Any Haskeller will recognize it pretty quickly.

You can generate a Bad Request to the dm_channel. This can be accomplished by setting content to None, for example.

If it returns with 400 Bad Request, you can DM them. If it returns with 403 Forbidden, you can't.

See the article, Using Records as Projections in JPA by Billy Korando. The following is a brief summary.

Jakarta Persistence (JPA; formerly Java Persistence API) implementations such as Hibernate depend on features either forbidden or not recommended by the JEP 395: Records spec: no-arg constructors, non-final fields, setters, etc.

➥ So, no, records cannot be used as JPA Entity.

You can use records with:

• CriteriaBuilder
• TypedQuery
• NativeQuery
• Mapping definition

Spring data has some support as well.

See that article linked above for details, and for links to two other articles.

I bumped into the same issue.

PostgreSQL Docker tags 13 and 14 seem to be using Debian's bulleye which seems to change things in regards to the file system.

At the moment there are two solutions:

1. Downgrade to PostgreSQL 13-buster, i.e. Docker tag postgres:13.4-buster, as it seems 14 does not have a -buster equivalent.
2. Upgrade current Docker you are running. From Docker version onwards 20.10.6, it seems to fix the issue.

As a reference to the issue on GitHub related to this issue, you can find it at root user has no permissions within container #884 .

For posterity, the solution from GitHub:

you'll need to update Docker, runc, and likely libseccomp on your host.