         internal init(_ generator: FreeModule<A, R>, _ divisor: R) {
             self.generator = generator
             self.divisor = divisor
+        }
+        
+        internal convenience init(_ a: A, _ divisor: R) {
+            self.init(FreeModule(a), divisor)
         }
         
         public var isFree: Bool {

//
//           B        A
// 0 -> R^m ---> R^n ---> M -> 0
//
// See: https://en.wikipedia.org/wiki/Free_presentation
//      https://en.wikipedia.org/wiki/Structure_theorem_for_finitely_generated_modules_over_a_principal_ideal_domain#Invariant_factor_decomposition

        return SimpleModuleStructure(summands, originalGenerators: generators, transitionMatrix: T2)
    }
}

extension Int: FreeModuleBase {}

public typealias AbstractSimpleModuleStructure<R: EuclideanRing> = SimpleModuleStructure<Int, R>

public extension AbstractSimpleModuleStructure where A == Int {
    public convenience init(rank r: Int, torsions: [R]) {
        let n = r + torsions.count
        let summands = (0 ..< r).map{ i in Summand(i, R.zero) }
            + torsions.enumerated().map{ (i, d) in Summand(FreeModule(i + r), d) }
        
        let generators = (0 ..< n).toArray()
        let matrix = ComputationalMatrix<R>.identity(n)
        
        self.init(summands, originalGenerators: generators, transitionMatrix: matrix)
    }
}

