如何在Haskell中实现基本的数据结构，如栈和队列

在Haskell中，可以使用列表和递归的方式来实现基本的数据结构，如栈和队列。下面是一个简单的示例：

1. 栈的实现：

栈是一种后进先出（LIFO）的数据结构。在Haskell中，可以简单地使用列表来实现栈。栈的基本操作包括压栈（push）、弹栈（pop）和查看栈顶元素（top）。

type Stack a = [a]

push :: a -> Stack a -> Stack a
push x stack = x:stack

pop :: Stack a -> Stack a
pop [] = []
pop (_:xs) = xs

top :: Stack a -> Maybe a
top [] = Nothing
top (x:_) = Just x

使用例子：

stackExample :: Stack Int
stackExample = push 1 (push 2 (push 3 []))

main :: IO ()
main = do
  putStrLn "Original Stack:"
  print stackExample
  
  let stack1 = push 4 stackExample
  putStrLn "
Stack after pushing 4:"
  print stack1
  
  let stack2 = pop stack1
  putStrLn "
Stack after popping an element:"
  print stack2
  
  let element = top stack2
  putStrLn "
Top element of the stack:"
  print element

输出：

Original Stack:
[3,2,1]

Stack after pushing 4:
[4,3,2,1]

Stack after popping an element:
[3,2,1]

Top element of the stack:
Just 3

2. 队列的实现：

队列是一种先进先出（FIFO）的数据结构。在Haskell中，可以使用两个列表来实现队列，一个用于保存前部元素，另一个用于保存后部元素。队列的基本操作包括入队（enqueue）、出队（dequeue）和查看队首元素（front）。

data Queue a = Queue [a] [a]

enqueue :: a -> Queue a -> Queue a
enqueue x (Queue front rear) = Queue front (x:rear)

dequeue :: Queue a -> Maybe (a, Queue a)
dequeue (Queue [] []) = Nothing
dequeue (Queue [] rear) = dequeue (Queue (reverse rear) [])
dequeue (Queue (x:front) rear) = Just (x, Queue front rear)

front :: Queue a -> Maybe a
front (Queue [] []) = Nothing
front (Queue [] rear) = front (Queue (reverse rear) [])
front (Queue (x:_) _) = Just x

使用例子：

queueExample :: Queue Int
queueExample = enqueue 1 (enqueue 2 (enqueue 3 (Queue [] [])))

main :: IO ()
main = do
  putStrLn "Original Queue:"
  print queueExample
  
  let queue1 = enqueue 4 queueExample
  putStrLn "
Queue after enqueueing 4:"
  print queue1
  
  case dequeue queue1 of
    Just (x, queue2) -> do
      putStrLn "
Queue after dequeuing an element:"
      print queue2
      putStrLn "
Dequeued element:"
      print x
    Nothing -> putStrLn "
Dequeue operation failed."
  
  let element = front queueExample
  putStrLn "
Front element of the queue:"
  print element

输出：

Original Queue:
Queue [3,2,1] []

Queue after enqueueing 4:
Queue [4,3,2,1] []

Queue after dequeuing an element:
Queue [4,3,2] []

Dequeued element:
1

Front element of the queue:
Just 1

以上是使用Haskell实现栈和队列的基本方法，根据具体需求可以进行相应的扩展和优化。