0votos

Separación de Pilas c++ en Haskell

por josejuan hace 3 años

.

El programa consiste en crear una pila dinámica, en la cual tendrá un menú de opciones 1 insertar elemento a la pila, 2 mostrar elementos de la pila, 3 borrar elemento de la pila, 4 separar la pila en dos ( respetando LIFO), 5 ver pila separada, 6 salir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
{-# LANGUAGE DeriveTraversable, DeriveFoldable, GeneralizedNewtypeDeriving #-}                                     
import Data.Traversable                                                                                            
import Control.Monad.Trans                                                                                         
import Control.Monad                                                                                               
import Data.Maybe                                                                                                  
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
-- La pila                                                                                                         
newtype Stack a = Stack { unStack :: [a] } deriving (Show, Functor, Foldable, Traversable, Monoid)                 
                                                                                                                   
∅ :: Stack a                                                                                                       
∅ = ∅                                                                                                              
                                                                                                                   
push :: a → Stack a → Stack a                                                                                      
push x = Stack ∘ (x:) ∘ unStack                                                                                    
                                                                                                                   
pop :: Stack a → Maybe (a, Stack a)                                                                                
pop (Stack (x:xs)) = Just (x, Stack xs)                                                                            
pop _              = Nothing                                                                                       
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
-- Un sistema para gestionar opciones de menú                                                                      
newtype Menu m s = Menu [(String, s → m s)]                                                                        
runMenu :: MonadIO m ⇒ Menu m s → s → m s                                                                          
runMenu (Menu ops) = run                                                                                           
  where run = λs → do                                                                                              
                        ↰_(zip [1…] ops) $ λ(i, (n, _)) → io $ putStrLn $ show i ⧺ ". " ⧺ n                        
                        io $ putStrLn "0. exit"                                                                    
                        (io $ putStr "\nSelecciona opción: " » readLn) ↪ (((η s): ((λ(_, k) → k s ↪ run) ↥ ops))‼) 
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
-- El interface solicitado usando los dos "módulos" anteriores para cualquier tipo de dato                         
runStack :: (MonadIO m, Read a, Show a) ⇒ m (Stack a)                                                              
runStack = flip runMenu ∅ $ Menu                                                                                   
              [ ("Insertar elemento", λs → flip push s ↥ io (putStr "\nEscribe el elemento: " » readLn))           
              , ("Mostrar elementos", λs → (io ∘ putStrLn) "\nLa lista es:" » ↰_s (io ∘ print) » η s)              
              , ("Sacar elemento", η ∘ snd ∘ fromJust ∘ pop) ]                                                     
                                                                                               
                                                                                               
                                                                                               
                                                                                               
-- Entonces puede usarse para ejecutar el ejercicio sobre cualquier tipo de dato, por ejemplo: 
--                                                                                             
-- $ runStack :: IO (Stack Int)               -- para números enteros                          
--                                                                                             
-- $ runStack :: IO (Stack String)            -- para cadenas                                  
--                                                                                             
-- $ runStack :: IO (Stack Bool)              -- para booleanos                                
--                                                                                             
-- $ runStack :: IO (Stack [(String, Int)])   -- para listas de pares cadena/número            
--                                                                                             
--                                                                                             
--                                                                                             
--                                                                                             
-- Un ejemplo de ejecución para el último caso sería:                                          
--                                                                                             
-- > runStack :: IO (Stack [(String, Int)])                                                    
-- 1. Insertar elemento                                                                        
-- 2. Mostrar elementos                                                                        
-- 3. Sacar elemento                                                                           
-- 0. exit                                                                                     
--                                                                                             
-- Selecciona opción: 1                                                                        
--                                                                                             
-- Escribe el elemento: [("Pedro", 34), ("Juan", 41)]                                          
-- 1. Insertar elemento                                                                        
-- 2. Mostrar elementos                                                                        
-- 3. Sacar elemento                                                                           
-- 0. exit                                                                                     
--                                                                                             
-- Selecciona opción: 1                                                                        
--                                                                                             
-- Escribe el elemento: [("Marta", 39)]                                                        
-- 1. Insertar elemento                                                                        
-- 2. Mostrar elementos                                                                        
-- 3. Sacar elemento                                                                           
-- 0. exit                                                                                     
--                                                                                             
-- Selecciona opción: 2                                                                        
--                                                                                             
-- La lista es:                                                                                
-- [("Marta",39)]                                                                              
-- [("Pedro",34),("Juan",41)]                                                                  
-- 1. Insertar elemento                                                                        
-- 2. Mostrar elementos                                                                        
-- 3. Sacar elemento                                                                           
-- 0. exit                                                                                     
--                                                      
-- Selecciona opción: 3                                 
-- 1. Insertar elemento                                 
-- 2. Mostrar elementos                                 
-- 3. Sacar elemento                                    
-- 0. exit                                              
--                                                      
-- Selecciona opción: 2                                 
--                                                      
-- La lista es:                                         
-- [("Pedro",34),("Juan",41)]                           
-- 1. Insertar elemento                                 
-- 2. Mostrar elementos                                 
-- 3. Sacar elemento                                    
-- 0. exit                                              
--                                                      
-- Selecciona opción: 0                                 
-- Stack {unStack = [[("Pedro",34),("Juan",41)]]}       
-- > 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.