```{-
Solution to "Knight's travails"

by Luke Plant, http://lukeplant.me.uk/

Confession: I got quite a bit of help from the Ruby solutions.
Notes: 1) I'm a total Haskell newbie, this could probably be lots better
2) It can be used as a complete command line program, otherwise
the main entry point is 'solve'

Interesting extras:
Unique positions on board paired with the maximum number of jumps it
takes to go from that position to any position on the board:

[(Pos x y, length \$ allNeighbours [Pos x y] []) | x <- [0..3], y <- [0..x]]

-}

import Data.List (nub)
import System.Environment (getArgs)
import System.Exit (exitFailure)

-- Pretty printing:
data Position = Pos Int Int deriving (Eq)

instance Show Position where
show (Pos x y) = toEnum (x + fromEnum 'a') :
toEnum (y + fromEnum '1') : []
showList ps = \x -> "[" ++ (unwords \$ map show ps) ++ "]" ++ x

parsePosition s =
case s of (x:y:[]) -> let x' = fromEnum x - fromEnum 'a'
ans = Pos x' y'
in if validPosition ans
then ans
else invalid s
otherwise -> invalid s
where invalid s = error ("'" ++ s ++ "' is not a valid position.")

-- Position is index from 0 to 7 on the board
validPosition (Pos x y) = let inrange z = 0 <= z && z < 8
in inrange x && inrange y

-- Calculate the Knight neighbours of a position, avoiding forbidden squares
knightjumps = [(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)]

neighbours (Pos x y) forbidden = do
(dx, dy) <- knightjumps
let newpos = Pos (x + dx) (y + dy)
guard (newpos `notElem` forbidden && validPosition newpos)
return newpos

isNeighbour (Pos x1 y1) (Pos x2 y2) = (x1 - x2, y1 - y2) `elem` knightjumps

-- All the neighbours of given start positions, returned
-- as a list of lists -- first item is nearest set of neighbours etc.
allNeighbours :: [Position] -> [Position] -> [[Position]]
allNeighbours startps forbidden =
let newps = nub \$ concatMap (\p -> neighbours p forbidden) startps
in if newps == []
then []
else [newps] ++ allNeighbours newps (startps ++ forbidden)

-- Search through the neighbours we have found,
-- and if we find our target, calculate (any) path back to first item
routeToPosition :: [[Position]] -> Position -> Maybe [Position]
routeToPosition ps item = routeToPosition' ps item []

-- helper which carries inverted list of 'used' [Position]
-- so we can go back and find the route:
routeToPosition' [] _ _             = Nothing
routeToPosition' (ps:pss) item used =
if item `elem` ps
then Just \$ (reverse \$ item : searchForPath used item)
else routeToPosition' pss item (ps:used) -- invert the 'used' list as we go
where
searchForPath [] _ = []
searchForPath (ps:pss) item =
let parent = head \$ filter (isNeighbour item) ps
in parent : searchForPath pss parent

solve :: Position -> Position -> [Position] -> Maybe [Position]
solve start end forbidden = let all = allNeighbours [start] forbidden
in routeToPosition all end

-- Main input and output
usage = "Usage: knight_travails startpos endpos [forbidden positions]"

main = do
args <- getArgs
if length args < 2
then do putStrLn ("Insufficient arguments.\n\n" ++ usage)
exitFailure
else let start = parsePosition (args!!0)
end   = parsePosition (args!!1)
forbidden = map parsePosition (drop 2 args)
solution = solve start end forbidden
in case solution of
Nothing -> do { putStrLn "No solutions"}
Just ps -> do { print ps }
```