Idiomatic way to generate python programs from a functional language?

To convert a Haskell program to pure Python code, you could in theory:

1. Identify the subset of Haskell functionality which your program needs
2. Define an intermediate representation which abstracts that functionality away from Haskell-specific syntax (e.g. expands "syntax sugar" into multiple semantic steps)
3. For each instruction in that intermediate representation, either a) identify a direct correspondence to Python syntax; or b) create an emulated implementation in Python
4. Convert the Haskell program to the intermediate representation
5. Convert the intermediate representation to pure Python code

This is roughly how "asm.js" (a predecessor of WebAssembly) worked - a subset of JavaScript was identified which could be used as the instructions of a virtual machine; compilers such as Emscripten compiled to that language as though it was a machine language.

However, this is probably not the best way to achieve your aim.

Your described use case does not require pure Python code, it requires code you can call from Python. The usual way of achieving this kind of inter-operability is using "bindings" or "foreign function interface" ("FFI") wrappers.

Large parts of libraries like NumPy and SciPy are written in various language like C, C++, and (perhaps surprisingly) Fortran, rather than Python. Since the aim in this case is performance, converting to Python code would defeat the purpose - it would execute slower than hand-coded Python for the same algorithms.

Instead, the compiled code is made available to Python functions via "extension modules".

So your actual process would look more like this:

1. Compile your Haskell program to native machine code
2. Create a C header which exports function for calling into that compiled code
3. Create a Python extension module which exposes those entry points to Python programs
4. Write and execute a Python program making use of the module

From a theoretical point of view, what you are doing is converting both the Haskell and Python code to a third language, which in this case is the machine language implemented by your hardware. In other cases, the target language might be JVM bytecode, .NET IR, or WebAssembly.

What you want to achieve (create an idiomatic Python library but actually write it in Haskell or Lean) is most likely impossible or not achievable with reasonable means.

First of all, "idiomatic" implies that the target library should use structuring and naming conventions which are probably foreign to the source language. For example, many Python libraries use modules, classes, try to be compatible with the calling conventions and data formats of related libraries etc.

Even if you had some tool that could translate some functional language into "equivalent" Python code it would most likely not know how a well-designed library interface in Python should look and how to build one.

Using lower-level libraries such as numpy or pytorch would additionally require that this tool understands the intent of your functional code (which probably does not call a compatible library) and creates code that uses these libraries to achieve the functionality that your library should provide.

In a way, that's what proponents of code-writing generative AI systems hope to achieve. IMHO, we're not there yet, not even close.

So if your goal is to create a pythonic math library, just write it in Python, perhaps using the experience you've gained writing similar code in functional languages to guide your design decisions. Waiting for the magical tool that does this for you is most likely not going to work, and dedicating your career to creating such tools is not much more promising.