Reducing allocations in arbitrary precision calculations with Julia
The following is a workaround for your speed and memory issue rather than a general review of your code.
Profiling is useful for investigating the source of performance issues, and Julia's standard library includes a profiling module (guide, doc).
Here's a basic use of it: (I'm using @eval just to interpolate in the construction of M)
using Profile
@eval @profile Hmn(12, 2, $(construct_M(192, 192)), 64)

julia&gt; Profile.print()
Overhead ╎ [+additional indent] Count File:Line; Function
=========================================================
    ╎963  @Base/task.jl:356; (::IJulia.var&quot;#15#18&quot;)()
...
    ╎    ╎   963  In[1]:61; Hmn(::Int64, ::Int64, ::Arr...
    ╎    ╎    1    In[1]:4; gamma_mpnq(::Int64, ::Int6...
...
  18╎    ╎    962  In[1]:46; maclaurin_exp(::Int64, ::I...
   1╎    ╎     1    In[1]:0; general_binomial(::Float6...
    ╎    ╎     14   In[1]:11; general_binomial(::Float6...
...
    ╎    ╎     786  In[1]:13; general_binomial(::Float6...
...
    ╎    ╎     97   In[1]:15; general_binomial(::Float6...
...

I've removed all the lines that point to code in external files. Of the 963 samples collected in Hmn, more than 800 were spent within calculations of general_binomial.
Looking at how general_binomial(alpha, k) is used, I noticed that it is called repeated with only a small number of different alpha and k values. Since it is a pure function (i.e., it does not interact with external state), basic memoization can be applied to speed it up.
We can use a Dict to cache the results (make sure it is defined with concrete key and value types). To allow for easy benchmarking, we'll define it as a global constant; for performance, it is important that global variables are constant (or otherwise type-constrained in code using it) so that type inference works (also, the compiled code can avoid an extra lookup).
Here's a simple way to do this. Rename general_binomial to _general_binomial, then create the Dict and redefine general_binomial to cache the results. Like so:
@isdefined(general_binomial) &amp;&amp; Base.delete_method.(methods(general_binomial))

const GENERAL_BINOMIAL_CACHE = Dict{Tuple{Float64, Int}, BigFloat}()

function general_binomial(alpha, k)
    return get!(GENERAL_BINOMIAL_CACHE, (alpha, k)) do
        _general_binomial(alpha, k)
    end
end

Benchmarking shows a substantial improvement in speed and memory use using the parameters you provided.
Before:
julia&gt; @benchmark Hmn(12, 2, $(construct_M(192, 192)), 64)
BenchmarkTools.Trial: 
  memory estimate:  435.29 MiB
  allocs estimate:  8543119
  --------------
  minimum time:     787.497 ms (5.88% GC)
  median time:      791.734 ms (5.83% GC)
  mean time:        792.690 ms (5.76% GC)
  maximum time:     802.070 ms (5.17% GC)
  --------------
  samples:          7
  evals/sample:     1

After: (the cache is cleared before each sample by empty!(GENERAL_BINOMIAL_CACHE))
julia&gt; @benchmark Hmn(12, 2, $(construct_M(192, 192)), 64) evals=1 setup=empty!(GENERAL_BINOMIAL_CACHE)
BenchmarkTools.Trial: 
  memory estimate:  12.74 MiB
  allocs estimate:  239309
  --------------
  minimum time:     10.684 ms (0.00% GC)
  median time:      12.844 ms (0.00% GC)
  mean time:        14.181 ms (7.58% GC)
  maximum time:     32.631 ms (14.03% GC)
  --------------
  samples:          353
  evals/sample:     1