searchalgorithms alternatives and similar packages
Based on the "Algorithms" category.
Alternatively, view searchalgorithms alternatives based on common mentions on social networks and blogs.

arithmoi
Number theory: primes, arithmetic functions, modular computations, special sequences 
toysolver
My sandbox for experimenting with solver algorithms. 
presburger
Decision procedures for Presburger arithmetic in Haskell 
imjanimation
Monorepo for a multiplayer game engine, and game examples 
textmetrics
Calculate various string metrics efficiently in Haskell 
lca
Improves the known complexity of online lowest common ancestor search to O(log h) persistently, and without preprocessing 
treeviz
Haskell library for visualizing algorithmic decomposition of computations. 
incrementalsatsolver
Simple, Incremental SAT Solving as a Haskell Library 
integerlogarithms
Integer logarithms, originally split from arithmoi package 
GraphSCC
Tarjan's algorithm for computing strongly connected components 
infinitesearch
An implementation of Martin Escardo's exhaustively searchable sets in Haskell. 
nonlinearoptimizationad
Wrapper of nonlinearoptimization package for using with ad and backprop packages 
primesieve
A collection of packages related to math, algorithms and science, in Haskell. 
adpmulti
Prototype of ADP for MCFL (multiple contextfree languages) 
editdistancevector
Calculate edit scripts and distances between Vectors. 
graphgenerators
A Haskell library for creating random Data.Graph instances using several pop 
editdistancelinear
Levenshtein edit distance in linear memory (also turns out to be faster than C++) 
stablemarriage
library around stable marriage algorithms 
bordacount
Haskell implementation of the Borda count election method 
epanethaskell
Call the EPANET toolkit via Haskell's Foreign Function Interface 
dgim
:chart_with_upwards_trend: Implementation of the DGIM algorithm in Haskell. 
learninghmm
Yet another Haskell library for hidden Markov models
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of searchalgorithms or a related project?
README
searchalgorithms
Haskell library containing common graph search algorithms
Lots of problems can be modeled as graphs, but oftentimes one doesn't want to use an explicit graph structure to represent the problem. Maybe the graph would be too big (or is infinite), maybe making an explicit graph is unwieldy for the problem at hand, or maybe one just wants to generalize over graph implementations. That's where this library comes in: this is a collection of generalized search algorithms, so that one doesn't have to make the graphs explicit. In general, this means that one provides each search function with a function to generate neighboring states, possibly some functions to generate additional information for the search, a predicate which tells when the search is complete, and an initial state to start from. The result is a path from the initial state to a "solved" state, or Nothing
if no such path is possible.
Documentation
Documentation is hosted on Hackage.
Acknowledgements
This library shares a similar functionality with the astar library (which I was unaware of when I released the first version of this library). astar
's interface has since influenced the development of this library's interface, and this library owes a debt of gratitude to astar
for that reason.
Examples
Changemaking problem
import Algorithm.Search (bfs)
countChange target = bfs (add_one_coin `pruning` (> target)) (== target) 0
where
add_one_coin amt = map (+ amt) coins
coins = [1, 5, 10, 25]
 countChange gives the subtotals along the way to the end:
 >>> countChange 67
 Just [1, 2, 7, 17, 42, 67]
Simple directed acyclic graph:
import Algorithm.Search (dfs)
import qualified Data.Map as Map
graph = Map.fromList [
(1, [2, 3]),
(2, [4]),
(3, [4]),
(4, [])
]
 Run dfs on the graph:
 >>> dfs (graph Map.!) (== 4) 1
 Just [3,4]
Using A* to find a path in an area with a wall:
import Algorithm.Search (aStar)
taxicabNeighbors :: (Int, Int) > [(Int, Int)]
taxicabNeighbors (x, y) = [(x, y + 1), (x  1, y), (x + 1, y), (x, y  1)]
isWall :: (Int, Int) > Bool
isWall (x, y) = x == 1 && (2) <= y && y <= 1
taxicabDistance :: (Int, Int) > (Int, Int) > Int
taxicabDistance (x1, y1) (x2, y2) = abs (x2  x1) + abs (y2  y1)
findPath :: (Int, Int) > (Int, Int) > Maybe (Int, [(Int, (Int, Int))])
findPath start end =
let next = taxicabNeighbors
cost = taxicabDistance
remaining = (taxicabDistance end)
in aStar (next `pruning` isWall) cost remaining (== end) start
 findPath p1 p2 finds a path between p1 and p2, avoiding the wall
 >>> findPath (0, 0) (2, 0)
 Just (6,[(0,1),(0,2),(1,2),(2,2),(2,1),(2,0)])

 This correctly goes up and around the wall