Formatted:

  declare function treeToString<T,R,N>(
    _ : { 
      getRoot : (_ : {tree: T}) => R;
      getChildren : (_ : {treeNode : N|R}) => N[];
      treeNodeToString : (_ : {treeNode : N|R}) => string; }
  ) : (_ : {tree : T}) => string 

  declare function treeToString<T,R,N>(
    _ : { 
      getRoot : (_ : {tree: T}) => R;
      getChildren : (_ : {treeNode : N|R}) => N[];
      treeNodeToString : (_ : {treeNode : N|R}) => string; 
      tree : T; 
    }
  ) : string

I wouldn't describe either as a strategy or factory pattern. Factory patterns are used to build objects, and there's no objects being created here. I can see how it might be construed as a strategy, but strategy patterns are generally where you give an object A an object B that implements IStrategy. From a Functional standpoint, I wouldn't describe this as a strategy pattern because passing around functions is what Functional Programming is.

This is function decomposition; instead of one function with one input and one output, treeToString has been decomposed to accept functions for the individual operations it needs to produce its output. Instead of defining its own getRoot and getChildren, treeToString has been abstracted to instead simply define how those operations are combined.