Reversing a string using a Stack ADT in Elm

Question

import Html exposing (..)
import String

type alias Stack = List String


push : String -> Stack -> Stack
push tok stack = 
 (tok :: stack)


pop : Stack -> (Maybe String, Maybe Stack)
pop stack = 
 let 
   top = List.head stack 
 in 
 (top, List.tail stack)


reverseString: String -> String
reverseString incoming = 
 let 
   stringStack = incoming 
    |> String.split "" 
    |> List.foldl push [] 
 in 
   -- How to use pop() here?
   List.foldr String.append "" stringStack


main : Html 
main = 
 "Hello World!"
 |> reverseString
 |> toString 
 |> text 

I am attempting on my own reverse of a string using push() and pop(). I am able to incorporate push, but not able to use pop within the function reverseString. What am I doing wrong here?

Answer 1

You are trying to List.foldr with your Stack ADT, but that's cheating; if Stack is really an ADT, we shouldn't be able to exploit that its a list!

List.foldr also matches the Stack ADT poorly, because it frees its function argument from handling the empty list, whereas the pop function forces us to treat both the case of the non-empty and empty stack.

If we want a Stack ADT, we'll have to do recursion through the stack manually, without using List.foldr. First, it'll be convenient to reduce the pop function to more concisely represent the two cases of "empty stack" and "non-empty stack":

pop : Stack -> Maybe (String, Stack)
pop stack = 
  case stack of 
    [] -> Nothing
    x :: xs -> Just (x, xs) 

Then we can formulate reverseString

reverseString : String -> String
reverseString string = 
  let
    loop stack = 
      case pop stack of 
        Nothing -> ""
        Just (symbol, stack') -> symbol ++ loop stack'
  in
    String.split "" string   -- Split the string into a list
    |> List.foldl push []    -- Push each letter on the stack
    |> loop                  -- Pop each letter off the stack 

It is perhaps easier to work directly with lists. Then Cons (::) is push and List.foldl is the function that reduces a stack by popping until empty.

reverseString2 : String -> String
reverseString2 = 
  String.split ""        -- "String -> Stack" (implicitly pushes)
  >> List.foldl (::) []  -- "Stack -> List" (reduces the stack)
  >> String.join ""      -- "List -> String" (nothing to do with stacks)

Answer 2

Elm doesn't have iteration at the language level so you need to use a data structure that supports iteration and mapping. In this case, I think lazy list is likely the best as you won't blow the stack via recursion.

In this case, stackIterator yields a lazy list of string from a stack. In order to get the lazy sequence of values we want, we need a function that we can repeatedly apply to its own result, and since pop returns a tuple of head, stack, that function is ((mhd, tl) -> pop tl). The next parts operate as a pipeline, first pulling out the left part of the tuple, second promising to terminate the list if the returned stack top is Nothing, third, turning the list of Maybes into strings via Maybe.withDefault.

By just substituting LL.foldr and the lazy list, you have a proper non-recursive iteration on your stack involving your pop function.

A couple of style notes:

• Your stack really wants String to be a type variable.
• As a style choice, you should prefer pattern match to functions returning maybe on lists.
• It makes the code cleaner if pop returns stack instead of maybe stack, since it can signal an empty stack via the maybe top result.

• My own elm style isn't perfect. There's probably a clever way to compose snd and pop that doesn't require an explicit lambda binding.

  import Html exposing (..)
  import String
  import Lazy.List as LL exposing (LazyList)
  
  type alias Stack = List String
  
  
  push : String -> Stack -> Stack
  push tok stack = 
   (tok :: stack)
  
  
  pop : Stack -> (Maybe String, Stack)
  pop stack = 
   case stack of
     hd :: tl -> (Just hd, tl)
     _ -> (Nothing, [])
  
  stackIterator : Stack -> LazyList String
  stackIterator stack =
   LL.iterate (\(mhd, tl) -> pop tl) (pop stack)
    |> LL.map fst
    |> LL.takeWhile (\a -> a /= Nothing)
    |> LL.map (Maybe.withDefault "") -- Default just for theoretical completeness
  
  reverseString: String -> String
  reverseString incoming = 
   let 
    stringStack = incoming 
     |> String.split "" 
     |> List.foldl push [] 
   in 
     LL.foldr String.append "" (stackIterator stringStack)
  
  
  main : Html 
  main = 
   "Hello World!"
   |> reverseString
   |> toString 
   |> text 
  

Answer 3

FWIW, I modified Rundberget's version to use String as a Stack. While it is not as generic as the other solutions, it does not use List.foldr or List.foldl, and ends up being somewhat shorter.

module SStack where

import String

type alias SStack = String

empty : SStack
empty =
  ""


push : String -> SStack -> SStack
push tok stacks = 
  tok ++ stacks


pop : SStack -> Maybe (Char, SStack)
pop stacks = 
  String.uncons stacks


reverse : SStack -> SStack
reverse stack =
  case (pop stack) of 
    Nothing ->
      empty
    Just(x, r) -> 
      push  (reverse r) (String.fromChar x)

and here's the driver module:

import SStack as Stack exposing (..)
import Html exposing (..)

reverseString : String -> String
reverseString str =
  Stack.reverse str 


main : Html.Html
main =
  reverseString "Hello World !" 
    |> Html.text