Rust as a gateway drug to Haskell(xion.io)

    import qualified Data.Vector.Mutable as V
    import           Control.Monad       (when)
    import qualified System.Random       as R
    
    main = do
        v <- V.replicate 10 0
        putStrLn "Initialised to zero"
        printThemAll v
    
        setIncreasing v
        putStrLn "Set with values increasing by 2"
        printThemAll v
    
        addRandomness v
        putStrLn "Added a random number to each"
        printThemAll v
    
    printThemAll v = loop 0 (V.length v)
        where loop i n = do
                when (i < n) $ do
                   e <- V.read v i
                   print e
                   loop (i + 1) n
    
    setIncreasing v = loop 0 (V.length v)
        where loop i n = do
                when (i < n) $ do
                  V.write v i (i * 2)
                  loop (i + 1) n
    
    addRandomness v = loop 0 (V.length v)
        where loop i n = do
                when (i < n) $ do
                  r <- R.randomIO
                  e <- V.read v i
                  V.write v i (e + r)
                  loop (i + 1) n

    algorithm partition(A, lo, hi) is
        pivot := A[hi]
        i := lo - 1    
        for j := lo to hi - 1 do
            if A[j] ≤ pivot then
                i := i + 1
                if i ≠ j then
                    swap A[i] with A[j]
        swap A[i+1] with A[hi]
        return i + 1

    partition a lo hi = do
        pivot <- Vector.read a hi
        i' <- newSTRef (lo - 1)
        j' <- newSTRef lo

        fix $ \loop -> do
            j <- readSTRef j'
            when (j < hi) $ do
                aj <- Vector.read a j
                when (aj <= pivot) $ do
                    i <- inc i'
                    when (i /= j) $
                        Vector.swap a i j
                inc j'
                loop

    i <- inc i'
    Vector.swap a i hi
    pure i

    partition a lo hi = do
        pivot <- Vector.read a hi
        i' <- newSTRef (lo - 1)
        j' <- newSTRef lo

        fix $ \loop -> do
            j <- readSTRef j'
            when (j < hi) $ do

                aj <- Vector.read a j
                when (aj <= pivot) $ do
                    i <- inc i'
                    when (i /= j) $
                        Vector.swap a i j

                inc j'
                loop

    i <- inc i'
    Vector.swap a i hi
    pure i

    partition a lo hi = do
        p <- state (randomR (lo, hi))
        lift $ do
            Vector.swap a hi p
         -- pivot <- Vector.read a hi
         -- ...

    quicksort gen vec = runST . flip evalStateT gen $ do
     -- pivot <- Vector.read a hi
     -- ...

    algorithm quicksort(A, lo, hi) is
        if lo < hi then
            p := partition(A, lo, hi)
            quicksort(A, lo, p – 1)
            quicksort(A, p + 1, hi)

    quicksort vec = runST $ do
        mvec <- thaw vec
        let loop lo hi = when (lo < hi) $ do
            p <- partition mvec lo hi
            loop lo (p-1)
            loop (p+1) hi
        loop 0 (Vector.length mvec - 1)
        freeze mvec

    quicksort vec = runST $ do
        mvec <- thaw vec

        let loop lo hi = when (lo < hi) $ do

            p <- partition mvec lo hi
            loop lo (p-1)

            loop (p+1) hi

        loop 0 (Vector.length mvec - 1)

        freeze mvec

    foldZip a b =
        List.foldl' (\r (cha, chb) -> if cha /= chb then r+1 else r) 0 (Text.zip a b)