How do you manipulate lists without altering the original list in functional programming?

In functional programming, you manipulate lists without altering the original by creating new lists based on the original one.

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. In this paradigm, data is immutable, meaning it cannot be changed after it's created. This includes lists. So, when you need to manipulate a list, you don't alter the original list. Instead, you create a new list that is a modified version of the original.

For example, suppose you have a list of numbers and you want to create a new list that contains only the even numbers from the original list. In a functional programming language, you might use a function like 'filter' that takes two arguments: a function that tests whether a number is even, and the original list. The 'filter' function would return a new list that contains only the numbers that pass the test. The original list remains unchanged.

This approach has several advantages. It makes your code easier to understand and reason about, because you don't have to keep track of how data changes over time. It also makes your code safer, because you can't accidentally change data that you didn't mean to change. And it can make your code more efficient, because the compiler can make optimisations based on the knowledge that data won't change.

There are many functional programming languages, including Haskell, Lisp, and Erlang, and many other languages have functional programming features. In JavaScript, for example, you can use the 'map', 'filter', and 'reduce' methods to manipulate arrays in a functional style. These methods all return new arrays and don't alter the original arrays.

In summary, in functional programming, you manipulate lists by creating new lists that are modified versions of the original lists. This approach is in line with the principles of immutability and statelessness that are central to the functional programming paradigm.