trans | a small and fast translator living in macOS menu bar | Menu library

Nobody uses this (invisible dependent quantification) for this purpose (where the dependency is not used) but it is the same as giving a Type -> .. parameter, implicitly.

You need to declare the schema namespace for the xs prefix that is used for the integer type declaration:

Before considering the problem of the translation, there is a more important aspect that has to be considered: if you want to create a transformation based on the center of a polygon, you must find that center. That point is called centroid, the geometric center of any polygon.

While there are simple formulas for all basic geometric shapes, finding the centroid of a (possibly irregular) polygon with an arbitrary number of vertices is a bit more complex.

Using the arithmetic mean of vertices is not a viable option, as even in a simple square you might have multiple points on a single side, which would move the computed "center" towards those points.

The formula can be found in the Wikipedia article linked above, while a valid python implementation is available in this answer.

I modified the formula of that answer in order to accept a sequence of QPoints, while improving readability and performance, but the concept remains the same:

Your problem is that your code don't uses Async all the way up.

Your Account class has the method Open, Close, Balance and Transaction and you use a AsyncReplyChannel but you use PostAndReply to send the message. This means: You send a message to the MailboxProcessor with a channel to reply. But, at this point, the method waits Synchronously to finish.

Even with Async.Parallel and multiple threads it can mean a lot of threads lock themsels. If you change all your Methods to use PostAndAsyncReply then your problem goes away.

There are two other performance optimization that can speed up performance, but are not critical in your example.

1. Calling the Length of a list is bad. To calculate the length of a list, you must go through the whole list. You only use this in Transaction to print the length, but consider if the transaction list becomes longer. You alway must go through the whole list, whenever you add a transaction. This will be O(N) of your transaction list.

2. The same goes for calling (List.sum). You have to calculate the current Balance whenever you call Balance. Also O(N).

As you have a MailboxProcessor, you also could calculate those two values instead of completly recalculating those values again and again.Thus, they become O(1) operations.

On top, i would change the Open, Close and Transaction messages to return nothing, as in my Opinion, it doesn't make sense that they return anything. Your examples even makes me confused of what the bool return values even mean.

In the Close message you return state.Opened before you set it to false. Why?

In the Open message you return the negated state.Opened. How you use it later it just looks wrong.

If there is more meaning behind the bool please make a distinct Discriminated Union out of it, that describes the purpose of what it returns.

You used an option throughout your code, i removed it, as i don't see any purpose of it.

Anyway, here is a full example, of how i would write your code that don't have the speed problems.

They are the same data type to share as much code as possible between Reader and ReaderT. As it stands, only runReader, mapReader, and withReader have any special cases. And withReader doesn't have any unique code, it's just a type specialization, so only two functions actually do anything special for Reader as opposed to ReaderT.

You might look at the module exports and think that isn't buying much, but it actually is. There are a lot of instances defined for ReaderT that Reader automatically has as well, because it's the same type. So it's actually a fair bit less code to have only one underlying type for the two.

Given that, your question boils down to asking why Reader is implemented on top of ReaderT, and not the other way around. And for that, well, it's just the only way that works.

Let's try to go the other direction and see what goes wrong.

One way can be to use lapply:

"shader works < iOS 15" doesn't mean the shader itself is always correct.

Some simple shader variable types like float, half, and fixed can give you total different result in different devices and OS.

"half" and "fixed" variables for better performance, while "float" for less bug.

It happens mostly on mobile, due to different CPU/GPU specs and also your Graphic APIs option.

Another key word will be "Color Space", please check Linear & Gamma option in your Unity Build Player settings.

A broken shader will return pink color. If it's not pink, it must be some math issue in your shader for wrong result. The shader code works very straight forwarding. If the rendering result changes after a while, it seems likely some variables are changed in runtime too. And obviously the plugin which you are using, is also included lots of math calculation between C# and Shader.

You can imagine this: When the C# code is trying to get variable from Shader, but shader return a wrong variable for your calculation in C#. Then, C# assign the wrong calculation result again to the Shader. This will become infinite loop for wrong result.

Unity UI Effects(with shader) are not reliable: Sometimes, they are just not updated... You have to force them update via script. Below commands may help sometimes, but not always...

The problem here is related to inlining. I do not understand it completly, but here is what I understand.

First we find that copy&pasting the definition of replicateM into the Submission 1 yields the same bad performance as Submission 2 (submission). However if we replace the INLINABLE pragma of replicateM with a NOINLINE pragma things work again (submission).

The INLINABLE pragma on replicateM is different from an INLINE pragma, the latter leading to more inlining than the former. Specifically here if we define replicateM in the same file Haskells heuristic for inlining decides to inline, but with replicateM from base it decides against inlining in this case even in the presence of the INLINABLE pragma.

sequenceA and traverse on the other hand both have INLINE pragmas leading to inlining. Taking a hint from the above experiment we can define a non-inlinable sequenceA and indead this makes Solution 2 work (submission).

A coercion Coercible A B does not imply a coercion Coercion (h A) (h B) for all h.

Consider this GADT: