Solved: find substring position in string

Alright, let’s get started on how to find a substring within a string in Haskell.

Haskell is a purely functional programming language known for its high level of abstraction and expressive syntax. One common task when dealing with strings is to find a substring within a larger string – that is, to identify the exact position where a certain sequence of characters appears.

For this purpose, we can leverage two built-in Haskell functions: `isPrefixOf` and `tails`. `isPrefixOf` checks whether a list is a prefix of another list, and `tails` generates all the ending parts of a list. We will also use the `elemIndex` function from `Data.List` to get the index of the first occurrence of a specific element.

Here is a simple solution to the problem:

import Data.List

findSubstring :: String -> String -> Maybe Int
findSubstring substr str = 
    elemIndex True $ map (isPrefixOf substr) (tails str)

The workings of the Code

The function `findSubstring` takes two arguments, `substr` and `str`, which represent the substring we are looking for and the string in which we are looking, respectively.

  • Firstly, `tails str` generates all possible endings of `str`. For example, given the string “hello”, `tails` would generate [“hello”, “ello”, “llo”, “lo”, “o”, “”].
  • Next, `map (isPrefixOf substr)` applies the function `isPrefixOf substr` to each element of the list produced by `tails str`. This yields a list of Boolean values, each indicating whether `substr` is a prefix of the corresponding element in the original list.
  • Finally, `elemIndex True` searches this list of Booleans for the first occurrence of `True`, which corresponds to the position of `substr` in `str`, and returns it wrapped in a `Maybe` datatype.

Key Functions and Libraries

Data.List is a Haskell library packed with useful functions for manipulating lists. Among other things, it exports the `isPrefixOf`, `tails`, and `elemIndex` functions which we used in our solution.

The `isPrefixOf` function is particularly crucial to our solution. By checking if our target substring is a prefix of each sublist, it essentially checks every possible start position of our substring within the original string.

Extrapolations and Variants

This simple approach can be extrapolated to perform more complex tasks, such as finding all occurrences of a substring, replacing a substring with another string, or breaking a string into chunks based on a delimiter.

As an example, to replace all occurrences of a substring, you could employ `intercalate` from Data.List to join the chunks obtained from breaking the original string at the positions of the target substring.

Despite its inherent simplicity and expressiveness, Haskell’s approach to string processing showcases the power of functional programming in tackling common tasks in a clean, readable, and concise manner.

Related posts:

Leave a Comment