peasant | LinkedIn reconnaissance utility written in Python3 | Portal library

Absolutely use AbstractUnit instead of Unit in your methods' argument type annotations. Unions are abstract types too, actually, but as you pointed out, you can't add new types to it. In either case, the method is compiled to a specialization for each concrete type like Knight or Peasant, so your methods' performance won't be different.

As for Arrays' element type parameters, there is the isbits Union optimization, but as the name suggests it only works if all the types in your Union are isbitstypes (no pointers, immutable). Your structs are mutable so that's already not applicable. See, memory access is faster when instances are directly stored in Arrays, and the element type parameter (T in Vector{T}) must be a concrete isbitstype to allow this. When the element type parameter is abstract or mutable, generally Arrays only directly store pointers to the actual instances because multiple or mutable concrete types can have unknown and varying memory size. If the abstract type is an isbits Union though, instances could be stored directly in the Array: enough memory is allocated per element to contain the largest concrete type in the Union as well as a tag byte for each element specifying its type. A byte only has 256 values, so presumably this only works for Unions of at most 256 concrete types.

Another possible optimization by using a Vector{Unit} over Vector{AbstractUnit} is Union-splitting a type instability. I'm really not going to be able to make an example method that explains it better than the linked blog, so I'll just give the short version. When Julia's compiler fails to infer the type of a variable in your method at all (::Any annotations in @code_warntype), inner method calls involving the variable must do type checks and dispatch (selecting the specialization) at run-time, which can cost significant time. However, if Julia's compiler can infer the variable to be a Union of a few concrete types (in practice, at most 4), conditional branches for each type can be used to eliminate most type checks and do dispatch at compile-time. Vector{AbstractUnit} can contain any number of types <: AbstractUnit, so the compiler cannot use Union-splitting. Vector{Unit} however lets the compiler know the elements must be either Knight or Peasant, which allows Union-splitting.

P.S. This is often a source of confusion for beginners, but while Unit is an abstract type, Vector{Unit} is a concrete type, just with an abstract type parameter. After all, it can have instances, all Arrays directly containing pointers to Knight or Peasant instances.

I would do something like this, I think must be better options but it works... so it's better than nothing

To process 100 million lines at once you would have to have 100 million threads. Another approach to improve the speed of your code is to split the work among different threads (lower than 100 million).
Because write and read operations from file are not asynchronous, you would be better off with reading all the file at the beginning of your program and write out thr processed data at the end. In the code below i will assume you do not care about the order at which wou write the file out. But if order is important you could set a dictionary that has as key the positional value of the current line being elaborated by a specific thread and at the end sort accordingly.

Use TextChannel.set_permissions and discord.utils.get as follows:

You made class variables, not instance variables. None of the data you want to save is part of the instance, so it doesn't get saved. (The parts that did get saved wouldn't have been saved either, except that you inadvertently shadowed the class variables with new instance variables later without realizing it, in code you didn't post.)

Use instance variables.

There are several things wrong with your program. Apart from anything else, even if halve worked the way you want it to work, how would b become zero? This is not the only problem!

However the particular case of halve happens because you are assuming programming languages to do what they normally do: incorrect arithmetic which is convenient for the machine, rather than correct arithmetic which is convenient for humans. Scheme tries hard to do correct arithmetic. What, mathematically, is 13/2? It's not 6, or 7, or 3, it's 13/2, or 6 + 1/2: it's a rational number, not an integer.

If you want the next integer below 13/2, the way you want to get it is by subtracting 1 before you divide: (halve (- 13 1)) is 6, exactly. So if you change that cond clause to have (halve (- a 1)) your program will be closer to working (but, in fact it will then fail to terminate, so in a sense it will be further from working...).

usort gets passed the elements from the array exactly as they are. i.e. in this case your array contains objects - therefore you need to do the comparison on the properties of the objects and not as elements in an array.

Instead of comparing the items as array elements like this:

Use if and elif not 2 different functions for same event.

Also you might need commands.Bot for a fully functional commanded bot.

Apparently the maximum length of a single line is 512 characters, and the line 144 has 579 characters