void optimize()
{

   Estimation bestEstimation;
   initialize(bestEstimation);
   

   while( !exitCriteriaReached())
   {
      Estimation newEstimation;
      suggestParams(newEstimation);
 
      if( newEstimation > bestEstimation)
      {
         bestEstimation = newEstimation;
      }
   }
}

//YIELD: представлять каждый параметр HTTP-запроса в виде списка со всеми возможными вариантами его декодирования в каноническую форму

    public delegate void DirectoryCallback(
      string source, ref string destination,
      ref bool newDestinationContainer, out bool skipSubitems);

    public delegate void FileCallback(
      string source, ref string destination,
      bool newDestinationContainer);

    public static void VisitAll(
      string source, ref string destination,
      DirectoryCallback directoryCallback, FileCallback fileCallback)
    {
      if (source.EndsWith("\\") || source.EndsWith("/"))
      {
        VisitAllInternal(
          source, ref destination,
          directoryCallback, fileCallback,
          !Directory.Exists(Path.GetDirectoryName(destination)));
      }
      else
      {
        fileCallback(
          source,
          ref destination,
          !Directory.Exists(Path.GetDirectoryName(destination.TrimEnd('\\','/'))));
      }
    }

    private static void VisitAllInternal(
      string source, ref string destination,
      DirectoryCallback directoryCallback, FileCallback fileCallback, bool newDestinationContainer)
    {
      bool skip = false;
      if (directoryCallback != null)
      {
        directoryCallback(source, ref destination, ref newDestinationContainer, out skip);
      }

      if (!skip)
      {
        if (fileCallback != null)
        {
          foreach (string fileName in Directory.GetFiles(source))
          {
            string destFile = destination + fileName.Substring(source.Length);
            fileCallback(fileName, ref destFile, newDestinationContainer);
          }
        }

        foreach (string dir in Directory.GetDirectories(source))
        {
          string sourceDir = dir + "\\";
          string destDir = destination + sourceDir.Substring(source.Length);
          VisitAllInternal(sourceDir, ref destDir, directoryCallback, fileCallback, newDestinationContainer);
        }
      }
    }

    public static void Copy(string source, string destination)
    {
      VisitAll(source, ref destination,
        delegate(string dir, ref string destDir, ref bool newDestinationContainer, out bool skip)
        {
          if (newDestinationContainer || !Directory.Exists(destDir))
          {
            Directory.CreateDirectory(destDir);
            newDestinationContainer = true;
          }
          skip = false;
        },
        delegate(string file, ref string destFile, bool newDestinationContainer)
        {
          File.Copy(file, destFile, !newDestinationContainer);
        });
    }

S>// skipped
S>

data Tree a = Leaf a | Branch a [Tree a] deriving (Read, Show)

-- А вот и тот самый универсальный алгоритм обхода.
foldTree leaf _ (Leaf v) = leaf v
foldTree leaf branch (Branch v vs) = branch v $ map (foldTree leaf branch) vs

getDirectoryTree path = liftM (Branch path) subPaths where
    subPaths = do
        cts <- liftM (map (path </>) . filter (`notElem` [".", ".."])) $ getDirectoryContents path
        (files, dirs) <- mapM doesFileExist cts >>= return . (map fst *** map fst) . (filter snd &&& filter (not . snd)) . zip cts
        dirTrees <- mapM getDirectoryTree dirs
        return $ map Leaf files ++ dirTrees
filterDirectories f = foldTree (return . Leaf) (\d subs -> sequence subs >>= filterM f_ >>= return . Branch d) where
    f_ path = case path of
        Leaf file -> f file False
        Branch dir _ -> f dir True
mapDirectories f = foldTree (\file -> liftM Leaf (f file)) (\dir subs -> liftM2 Branch (f dir) (sequence subs))
eachFilePath f = foldTree f (\dir subs -> f dir >> sequence_ subs)

withDirectoryTree :: FilePath -> (FilePath -> Bool -> IO Bool) -> (FilePath -> IO FilePath) -> (FilePath -> IO ()) -> IO ()
withDirectoryTree path filterPath mapPath actPath = getDirectoryTree path >>= filterDirectories filterPath >>= mapDirectories mapPath >>= eachFilePath actPath

withDirectoryTree "c:\\some\\folder" (\path b -> return (b || path =~ ".mp3")) (\path -> return $ replaceExtension path "exe") putStrLn