sum-type | A simple , serializable sum-type format | Architecture library

There are three issues in your code:

1. According to the specification PBKDF2 is used with HMAC-SHA1 (and not HMAC-SHA256), s. 3.4.2 Encryption Process

2. The key s derived with PBKDF2WithHmacSHA256 is an instance of PBKDF2KeyImpl, which requires a UTF8 string as password (see docs of the PBKDF2KeyImpl class). Here, however, the password is a hash, which is generally not compatible with UTF8. A possible solution is to replace PBEKeySpec with BouncyCastle's PKCS5S2ParametersGenerator, which expects the password as byte array (in init). For this solution replace

First, I believe the type you meant to say was:

In the cases of ordinary constructors, the compiler can use the type definition to distinguish between:

I encountered the same problem. This issue may arise when files inside ~.aws are modified manually and not via the "aws configure" command.

Did you try to:

1. Delete the "config" and "credentials" files (located at ~.aws)
2. run the "aws configure" command (recreating the files you deleted in #1)

That has fixed the problem for me.

This is mainly because I use other tools that also modify these files.

I hope it helps.

A very natural way to define a type of finite lists is to state: a list is either empty, or the addition of an element at (say) the front of an existing list. This is what the recursive sum type you refer to represents. An option type is simply another kind of sum type that represents two possibilities: either it does not contain a payload, or it does. The two types, lists and options, represent different things.

I have sometimes seen constructors of recursive types, like lists, classified as base constructors or recursive constructors, paralleling their use in proofs by structural induction. This makes clear what you mean, although other people may use slightly different terms.

On the one hand, the type of lists thus defined is a perfectly legitimate mathematical entity. On the other, you wonder whether lists are an adequate model of sequences. In programming terms, answering this question involves defining the abstract data type of sequences, including their desired properties, and proving that implementing sequences via lists satisfies those properties. For example, from the article you link:

The number of elements (possibly infinite) is called the length of the sequence.

So, if you want to represent infinite sequences, the type of finite lists by itself will be insufficient. The section on formal definitions in the same article considers sequences as functions, and this may be another way to model them. Finite lists are a simple, reasonable candidate to represent finite sequences.

One way to do that is using records:

After searching for some time and thinking about it I concluded there are two possible solutions:

If number of SharingIdTypes is static or rarely changes (means, it is OK to recompile the source to change it or alter the DB schema), the proper way to handle the problem is to have to entities for each sharing type:

Why are you using dataproc? Would not a gsutil command be simpler?

eg:

why is [Copy] not an auto-trait like Sync and Send for those types which can implement it and have opt-out semantics instead of opt-in?

Copy used to be automatically implemented by types that could implement it. This behavior was changed in December 2014, not too long before Rust 1.0.

Should the Copy trait always be implemented if possible?

Not necessarily. When developing a library, the choice to implement Copy or not on a type has an impact on forward compatibility. Removing a Copy implementation on a type is a breaking change (users of that type may rely on the type being copied instead of moved), and as such would impose a major version bump on the library in order to respect semantic versioning. In particular, if a type is able to implement Copy now but you think it's possible that the type may evolve such that it could no longer implement Copy, you should play it safe and not implement Copy on that type.

Another reason for not implementing Copy is, as you mentioned, large types. It may be useful to implement only Clone for such types, as usually "Clone but not Copy" indicates that cloning the value is not "cheap". However, even if a type is not Copy, one could still cause a large memory copy operation by merely moving the value (though if you're lucky, the compiler might optimize it away).

Can implementing Copy be detrimental to performance if the size of the type is "large"?

Not if you never perform a copy on the type! Keep in mind that the only difference between a move and a copy is that a move makes the source unusable (i.e. the compiler will raise an error if you try to use a value after it was moved), while a copy doesn't; both operations are implemented as a shallow memory copy.