DAGX, with CondNodes

[thorwhalen]

Note: See flow_control notebook (Sep 2023) for some step by step discussion of the need for flow control functionalities and code to implement some.

Flow control (if-then-else, switch-case) is problem pattern that comes up a lot in trying to fit things into the current "only functions" DAG. Perhaps it's time to extend the DAG with this capability. There's arguments against introducing flow-control as well as alternatives to solve problems where they show up (see appendix below), but if we don't manage to express our problem patterns easily, we should at least allow an interface for the user to express control flow.

An example would be something like the binary conditional node:

Which, if the actions should be taken on the item itself, might be represented like so:

This in turn could be expressed by a "functional" DAG like so:

Where one of the actions is wrapped to only return None, or some sentinel.

Below is some "ideas" python code. This code wasn't actually run, and is definitely not finished.
This is just some ideas-in-code explorations.

from typing import Callable, MutableMapping
from meshed import DAG, FuncNode
from dataclasses import dataclass

# TODO: Make it so that case values can be functions, automatically made into DAGs
class CondNode(FuncNode):
    """A FuncNode whose purpose is to act as a if-then-else, or more generally,
    a switch statement.
    """
    def __init__(self, *args, case: dict=(), **kwargs):
        super().__init__(*args, **kwargs)
        self.case = dict(case)
        assert all(isinstance(v, DAG) for v in self.case.values())
        # self.out = None  # will ignore out instead, but need to find clean way
    
    def call_on_scope(self, scope: MutableMapping, write_output_into_scope=False):
        return super().call_on_scope(scope, write_output_into_scope=False)

class DAGX(DAG):
    def _call_func_nodes_on_scope(self, scope=None):
        for func_node in self.func_nodes:
            if isinstance(func_node, CondNode):
                answer = func_node.call_on_scope(scope)
                if answer in func_node.out:
                    dag_for_answer = func_node.out[answer]
                    assert isinstance(dag_for_answer, DAG)
                    dag_for_answer.call_on_scope(scope)
            func_node.call_on_scope(scope)

Appendix: Why should control flow constructs like if-then-else and switch-case be avoided when possible?

The notion that control flow constructs like if-then-else and switch-case should be minimized comes from various software design principles and patterns which aim to improve the maintainability, readability, and scalability of code. Let's discuss the reasons and alternatives:

• Object-Oriented Polymorphism: In object-oriented programming, using polymorphism is often preferable over using if or switch statements for behavior that varies according to type. This practice is known as the Replace Conditional with Polymorphism refactoring, and it's part of the broader Open/Closed Principle. You can find more about this in the book "Refactoring: Improving the Design of Existing Code" by Martin Fowler.
• Single Responsibility Principle: Having too many conditional statements can be a sign that a class or function is doing too much and should be broken down into smaller, more focused pieces. This is part of the Single Responsibility Principle, which you can read about in "Clean Code: A Handbook of Agile Software Craftsmanship" by Robert C. Martin.
• Complexity and Maintainability: Conditionals tend to make code more complex and harder to understand. This increases the likelihood of bugs and makes the code harder to modify. Thomas DeMarco and Timothy Lister talk about how complexity affects maintainability in "Peopleware: Productive Projects and Teams".
  Table-Driven Methods: Sometimes, you can replace a complex if or switch with a table lookup. This can make the code more concise and easier to modify. This technique is discussed in the book "Code Complete: A Practical Handbook of Software Construction" by Steve McConnell.
• Functional Programming Paradigm: In functional programming, the use of higher-order functions, pattern matching, and function composition often results in code that has fewer explicit control flow constructs. If you're interested in the functional programming paradigm, "Structure and Interpretation of Computer Programs" by Harold Abelson and Gerald Jay Sussman is a classic text.
  State Pattern: For state-dependent behavior, using a State Pattern can help in avoiding conditionals. It allows objects to alter their behavior when their internal state changes. You can read more about it in "Design Patterns: Elements of Reusable Object-Oriented Software" by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.

It's important to note that conditionals are a fundamental part of programming, and it’s not about avoiding them entirely but rather about using them judiciously. Replacing conditionals with design patterns and principles should be guided by the complexity and needs of the problem you are solving, and not just for the sake of avoiding conditionals.

[thorwhalen]

To write a function that uses the ast (Abstract Syntax Tree) module in Python to detect if/elif/else blocks in code and replace them with a functional form, we need to follow these steps:

1. Parse the code into an AST.
2. Traverse the AST to find If nodes.
3. Replace each If node with a call to a custom function if_elif_else.
4. Generate the new source code from the modified AST.

Here's a basic implementation of this idea:

import ast
import inspect
from typing import Callable, Iterable

class IfTransformer(ast.NodeTransformer):
    def visit_If(self, node):
        # This method is called for every "If" node in the AST

        # Process the 'if' condition and body
        if_ = self._process_if(node.test, node.body)

        # Process 'elif' and 'else' parts
        elifs = []
        else_ = None
        for orelse in node.orelse:
            if isinstance(orelse, ast.If):
                elifs.append(self._process_if(orelse.test, orelse.body))
            else:
                else_ = self._process_else(orelse)

        # Create a call to the custom if_elif_else function
        func_call = ast.Call(
            func=ast.Name(id='if_elif_else', ctx=ast.Load()),
            args=[if_],
            keywords=[
                ast.keyword(arg='elifs', value=ast.List(elts=elifs, ctx=ast.Load())),
                ast.keyword(arg='else_', value=else_)
            ]
        )

        return ast.copy_location(func_call, node)

    def _process_if(self, test, body):
        # Process the 'if' or 'elif' part
        # ...

    def _process_else(self, body):
        # Process the 'else' part
        # ...

def if_elif_else(if_: Callable, elifs: Iterable[Callable] = (), else_: Callable = None):
    # Custom function to handle if/elif/else logic
    # ...

def transform_code(code):
    tree = ast.parse(code)
    transformer = IfTransformer()
    new_tree = transformer.visit(tree)
    return ast.unparse(new_tree)

# Example usage
code = """
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5")
else:
    print("x is 5 or less")
"""

new_code = transform_code(code)
print(new_code)

In this implementation, the IfTransformer class is a subclass of ast.NodeTransformer. It overrides the visit_If method to process If nodes. The _process_if and _process_else methods should be implemented to handle the conversion of the if/elif/else parts into the appropriate functional form.

The if_elif_else function is a placeholder for your custom logic to handle the functional form of if/elif/else statements.

Please note that this is a simplified example. The actual implementation of _process_if and _process_else methods, as well as the if_elif_else function, would depend on how you want to represent and execute these conditional blocks in a functional style. Also, the ast.unparse function used to generate the new source code is available in Python 3.9 and later. For earlier versions, you might need to use a third-party library like astor to convert the AST back to source code.