agree | Voice , video and text communication service based on Discord | Runtime Evironment library
kandi X-RAY | agree Summary
kandi X-RAY | agree Summary
Voice, video and text communication service based on Discord
Support
Quality
Security
License
Reuse
Top functions reviewed by kandi - BETA
Currently covering the most popular Java, JavaScript and Python libraries. See a Sample of agree
agree Key Features
agree Examples and Code Snippets
Community Discussions
Trending Discussions on agree
QUESTION
Simple code as below or godbolt has different results from gcc, clang and Visual Studio.
...ANSWER
Answered 2022-Feb-21 at 14:38From [expr.prim.lambda.capture]/3:
A lambda-expression shall not have a capture-default or simple-capture in its lambda-introducer unless its innermost enclosing scope is a block scope ([basic.scope.block]) or it appears within a default member initializer and its innermost enclosing scope is the corresponding class scope ([basic.scope.class]).
Which means that captures such as [n]
, [&n]
or [&]
are not allowed in trailing return types or noexcept
specifiers, but initialized captures such as [i = 1]
are.
So GCC is right to reject the first two function definitions and GCC and Clang are right to reject the last one.
QUESTION
I stumbled over the following piece of code. The "DerivedFoo"
case produces different results on MSVC than on clang or gcc. Namely, clang 13 and gcc 11.2 call the copy constructor of Foo
while MSVC v19.29 calls the templated constructor. I am using C++17.
Considering the non-derived case ("Foo"
) where all compilers agree to call the templated constructor, I think that this is a bug in clang and gcc and that MSVC is correct? Or am I interpreting things wrong and clang/gcc are correct? Can anyone shed some light on what might be going on?
Code (https://godbolt.org/z/bbjasrraj):
...ANSWER
Answered 2022-Feb-06 at 21:41It is correct that the constructor template is generally a better match for the constructor call with argument of type DerivedFoo&
or Foo&
than the copy constructors are, since it doesn't require a const
conversion.
However, [over.match.funcs.general]/8 essentially (almost) says, in more general wording, that an inherited constructor that would have the form of a move or copy constructor is excluded from overload resolution, even if it is instantiated from a constructor template. Therefore the template constructor will not be considered.
Therefore the implicit copy constructor of DerivedFoo
will be chosen by overload resolution for
QUESTION
I was testing this code (https://godbolt.org/z/fe6hhbeqW)...
...ANSWER
Answered 2022-Jan-29 at 13:14It doesn't matter that i
is guaranteed to be evaluated only at compile-time when its value is known in an abstract sense.
It also doesn't matter whether the function is consteval
or constexpr
or none of these.
The language is still statically typed and nth_type_t;
must in any given instantiation of the function refer to exactly one type. If i
can change in the for
loop, that is not possible to guarantee.
The language requires that the expression i
when used as template argument is by itself a constant expression, independently of whether the whole function body can only be evaluated as part of a larger constant expression. But i
is neither declared constexpr
, nor declared const
with constant initializer.
QUESTION
Pardon the confusing title.
I have this code, which is accepted by GCC, Clang, and MSVC:
...ANSWER
Answered 2022-Jan-25 at 08:25The declaration auto helper() -> Writer;
doesn't cause instantiation of Writer
because the return type is not required to be complete.
The definition of helper()
and with it the implicit instantiation of Writer
are then in a complete-class context, which it seems the compilers assume means that the member function definition is located after the class definition and that the point-of-instantiation of Writer
is then also after the class definition.
I don't know whether this is actually how it is supposed to work or which paragraph in the standard would specify this behavior, though.
Reading the tag only in the body of another (static) member function causes the read to also be located in a complete class context, i.e. after the class definition in the above interpretation, which is why it works again.
QUESTION
I would like to make a component in SvelteKit which has a randomized parameter. The problem is that the value this parameter takes is different for when the page is rendered server-side versus when that page becomes hydrated.
For example, consider this component:
...ANSWER
Answered 2022-Jan-15 at 01:08You have a few options here:
- Set the random numbers in onMount so they're only set on the client. This will cause a FOUC, however, since the box won't be server rendered.
QUESTION
I am calling slack API(conversations.history) to get channel messages. I want to retrieve sender name in message response. how can i get it?
below is my message response:
...ANSWER
Answered 2022-Jan-17 at 17:49You can use the user id returned from the user
key to make a call to users.info
after you receive that payload.
QUESTION
I have a Python 3 application running on CentOS Linux 7.7 executing SSH commands against remote hosts. It works properly but today I encountered an odd error executing a command against a "new" remote server (server based on RHEL 6.10):
encountered RSA key, expected OPENSSH key
Executing the same command from the system shell (using the same private key of course) works perfectly fine.
On the remote server I discovered in /var/log/secure
that when SSH connection and commands are issued from the source server with Python (using Paramiko) sshd complains about unsupported public key algorithm:
userauth_pubkey: unsupported public key algorithm: rsa-sha2-512
Note that target servers with higher RHEL/CentOS like 7.x don't encounter the issue.
It seems like Paramiko picks/offers the wrong algorithm when negotiating with the remote server when on the contrary SSH shell performs the negotiation properly in the context of this "old" target server. How to get the Python program to work as expected?
Python code
...ANSWER
Answered 2022-Jan-13 at 14:49Imo, it's a bug in Paramiko. It does not handle correctly absence of server-sig-algs
extension on the server side.
Try disabling rsa-sha2-*
on Paramiko side altogether:
QUESTION
I have this lambda style function call
...ANSWER
Answered 2021-Dec-15 at 21:20Parentheses are not needed here:
QUESTION
(Disclaimer: I'm not 100% sure how codatatype works, especially when not referring to terminal algebras).
Consider the "category of types", something like Hask but with whatever adjustment that fits the discussion. Within such a category, it is said that (1) the initial algebras define datatypes, and (2) terminal algebras define codatatypes.
I'm struggling to convince myself of (2).
Consider the functor T(t) = 1 + a * t
. I agree that the initial T
-algebra is well-defined and indeed defines [a]
, the list of a
. By definition, the initial T
-algebra is a type X
together with a function f :: 1+a*X -> X
, such that for any other type Y
and function g :: 1+a*Y -> Y
, there is exactly one function m :: X -> Y
such that m . f = g . T(m)
(where .
denotes the function combination operator as in Haskell). With f
interpreted as the list constructor(s), g
the initial value and the step function, and T(m)
the recursion operation, the equation essentially asserts the unique existance of the function m
given any initial value and any step function defined in g
, which necessitates an underlying well-behaved fold
together with the underlying type, the list of a
.
For example, g :: Unit + (a, Nat) -> Nat
could be () -> 0 | (_,n) -> n+1
, in which case m
defines the length function, or g
could be () -> 0 | (_,n) -> 0
, then m
defines a constant zero function. An important fact here is that, for whatever g
, m
can always be uniquely defined, just as fold
does not impose any contraint on its arguments and always produce a unique well-defined result.
This does not seem to hold for terminal algebras.
Consider the same functor T
defined above. The definition of the terminal T
-algebra is the same as the initial one, except that m
is now of type X -> Y
and the equation now becomes m . g = f . T(m)
. It is said that this should define a potentially infinite list.
I agree that this is sometimes true. For example, when g :: Unit + (Unit, Int) -> Int
is defined as () -> 0 | (_,n) -> n+1
like before, m
then behaves such that m(0) = ()
and m(n+1) = Cons () m(n)
. For non-negative n
, m(n)
should be a finite list of units. For any negative n
, m(n)
should be of infinite length. It can be verified that the equation above holds for such g
and m
.
With any of the two following modified definition of g
, however, I don't see any well-defined m
anymore.
First, when g
is again () -> 0 | (_,n) -> n+1
but is of type g :: Unit + (Bool, Int) -> Int
, m
must satisfy that m(g((b,i))) = Cons b m(g(i))
, which means that the result depends on b
. But this is impossible, because m(g((b,i)))
is really just m(i+1)
which has no mentioning of b
whatsoever, so the equation is not well-defined.
Second, when g
is again of type g :: Unit + (Unit, Int) -> Int
but is defined as the constant zero function g _ = 0
, m
must satisfy that m(g(())) = Nil
and m(g(((),i))) = Cons () m(g(i))
, which are contradictory because their left hand sides are the same, both being m(0)
, while the right hand sides are never the same.
In summary, there are T
-algebras that have no morphism into the supposed terminal T
-algebra, which implies that the terminal T
-algebra does not exist. The theoretical modeling of the codatatype Stream (or infinite list), if any, cannot be based on the nonexistant terminal algebra of the functor T(t) = 1 + a * t
.
Many thanks to any hint of any flaw in the story above.
...ANSWER
Answered 2021-Nov-26 at 19:57(2) terminal algebras define codatatypes.
This is not right, codatatypes are terminal coalgebras. For your T
functor, a coalgebra is a type x
together with f :: x -> T x
. A T
-coalgebra morphism between (x1, f1)
and (x2, f2)
is a g :: x1 -> x2
such that fmap g . f1 = f2 . g
. Using this definition, the terminal T
-algebra defines the possibly infinite lists (so-called "colists"), and the terminality is witnessed by the unfold
function:
QUESTION
In the following program struct S
provides two conversion operators: in double
and in long long int
. Then an object of type S
is passed to a function f
, overloaded for float
and double
:
ANSWER
Answered 2021-Nov-08 at 03:24GCC and Clang are correct. The implicit conversion sequences (user-defined conversion sequences) are indistinguishable.
(emphasis mine)
Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:
...
(3.3) User-defined conversion sequence U1 is a better conversion sequence than another user-defined conversion sequence U2 if they contain the same user-defined conversion function or constructor or they initialize the same class in an aggregate initialization and in either case the second standard conversion sequence of U1 is better than the second standard conversion sequence of U2.
The user-defined conversion sequences involves two different user-defined conversion functions (operator double()
and operator long long int()
), so compilers can't select one; the 2nd standard conversion sequence won't be considered.
Community Discussions, Code Snippets contain sources that include Stack Exchange Network
Vulnerabilities
No vulnerabilities reported
Install agree
Support
Reuse Trending Solutions
Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 650 million Knowledge Items
Find more librariesStay Updated
Subscribe to our newsletter for trending solutions and developer bootcamps
Share this Page