Design patterns are essential to any non-trivial software design, but their usage is often associated with excessive complexity. The complexity of patterns-based solutions may be inherent and appropriate to the problem, but it becomes too high in other cases. In these cases, design patterns create complexity instead of handling it. The present work studies one of the possible reasons for that, the insufficient expressiveness of programming languages. Due to lower expressiveness, programming languages struggle to represent the mental constructs that patterns encode. The solution proposed in the present work is generalising typical programming language constructs. The generalisation is achieved by describing such constructs themselves as patterns. Subsequent formalisation using a type-theoretical toolset gives these patterns a necessary strict form. The author proposes a set of such patterns and their formalisation for elemental data composition and computation constructs. The effect of such changes is analysed on the example of an emulator of the MIX imaginary computer. This example project demonstrated that even such an expressive language as Scala is inconvenient in certain situations. The present work discusses how the implementation and evolution of this project could be more straightforward if the described patterns were supported. The thesis includes an introduction, six chapters, and a conclusion. It contains 148 pages, not including appendices, 23 figures, three tables, 128 bibliography sources, and two appendices.