List monad


Martin McBride, 2020-07-02
Tags monad list monad design pattern
Categories functional programming

This article is part of a series on functional programming.

In the article on the Failure monad we looked at a simple definition of what a monad is:

A monad is a design pattern that allows us to add a context to data values, and also allows us to easily compose existing functions so that they execute in a context aware manner.

In this article we will look at the List monad. This is a monad that allows us to process lists of values, without cluttering our code with looping constructs.

How a List monad is used

As with the Failure monad, our List monad should do three main things:

  • Allow us to wrap a value (in this case, a list value) in a List monad.
  • Allow us to apply ant existing function to the entire list, using bind().
  • Allow us to retrieve the List from a monad.

So a simple use might be like this:

k = List([1, 2, 3])
n = k.bind(neg)
print(n)              # List([-1, -2, -3])

We will call our monad List because that is the name that is commonly used for similar monads in other languages. Notice that a List monad is quite different to a normal Python list.

List monad implementation

Based on the previous implementation of the Failure monad, here is our List monad:

class List():

    def __init__(self, value):
        self.value = value

    def get(self):
        return self.value

    def bind(self, f):
        result = list(map(f, self.value))
        return List(result)

    def __str__(self):
        return 'List(' + ', '.join(map(str, self.value)) + ')'

    def __or__(self, f):
        return self.bind(f)

The List monad just wraps a single value, which should be a list or other sequence. This is stored as self.value.

The bind function uses map to apply the supplied function f to each element in self.value. The resulting list is wrapped in a new List monad.

We override str to return 'List([contents of list])'. Finally we override the or operator | so we can use it as a bind operator.

See also

If you found this article useful you might be interested in my ebook Functional Programming in Python.

Tag cloud

2d arrays abstract data type alignment and array arrays bezier curve built-in function close closure colour comparison operator comprehension context conversion data types design pattern device space dictionary duck typing efficiency encryption enumerate filter font font style for loop function function plot functools generator gif gradient html image processing imagesurface immutable object index input installing iter iterator itertools lambda function len linspace list list comprehension logical operator lru_cache mandelbrot map monad mutability named parameter numeric python numpy object open operator optional parameter or path positional parameter print pure function radial gradient range recursion reduce rotation scaling sequence slice slicing sound spirograph str stream string subpath symmetric encryption template text text metrics transform translation transparency tuple unpacking user space vectorisation webserver website while loop zip

functional programming

  1. Contents
  2. Introduction
  3. Functions
  4. - Pure functions
  5. Iterators
  6. - Iterators vs iterables
  7. - Built-in functions on iterables
  8. - Transforming iterables
  9. - Map/reduce example
  10. - Generators
  11. Functional design patterns
  12. - Recursion
  13. - Closures
  14. Monads
  15. - Failure monad
  16. - List monad
  17. - Maybe monad

See also

  1. Recent articles
  2. All articles
  3. All tags
  4. All categories

Books

  1. NumPy Recipes
  2. Functional Programming in Python
  3. Computer graphics (PyCairo)

Links

  1. twitter
  2. schoolcoders.com

Subscribe to the pythoninformer newsletter

* indicates required

Copyright (c) Axlesoft Ltd 2020