FSlash 0.1.0

Practical functional programming for Python 3.8+

FSlash

Python :heart: F#

FSlash (F/) aims to be a solid library for practical functional programming in Python 3.8+ inspired by F#. By practical we mean that the goal of the library if to enable you to do meaningful and productive functional programming in Python instead of being a Monad tutorial.

Python is a multi-paradigm programming language that also supports functional programming constructs such as functions, higher-order functions, lambdas, and in many ways favors composition over inheritance.

F# is a functional programming language for .NET that is succinct (concise, readable and type-safe) and kind of Pythonic. F# looks a lot more like Python than C# and F# can also do a lot of things better than Python:

• Strongly typed, if it compiles it usually works
• Type inference, the compiler deduces types during compilation
• Expression based language

Better Python with F#

FSlash tries to make a better Python by providing several functional features inspired by F# into Python. This serves two purposes:

• Make it easier for Python programmers to learn F# by starting out in a programming language they already know. Then get inspired to try out F# by itself.
• Make it easier for F# developers to use Python when needed, and re-use many of the concepts and abstractions that they already know and love.

FSlash will enable you to work with Python along with F# using many of the same programming concepts and abstractions. This enables concepts such as Railway oriented programming (ROP) for better and predictable error handling. Pipelining for workflows, computational expressions, etc.

Getting Started

You can install the latest fslash from PyPI by running pip (or pip3). Note that fslash only works for Python 3.8+.

pip install fslash

Why

• I love F#, and know F# quite well. I'm the creator of projects such as Oryx, Fable.Reaction and Feliz.ViewEngine
• I love Python, and know Python really well. I'm the creator of both RxPY and OSlash, two functional style libraries for Python. So I already know that Python can do anything that F# can. The challenge is how to make it look nice (syntactic sugar).

For a long time I'm been wanting to make a "bridge" between these two languages and got inspired to write this library after watching "F# as a Better Python" - Phillip Carter - NDC Oslo 2020. Doing a transpiler like Fable for Python is one option, but a Python library may give a lower barrier and a better introduction to existing Python programmers.

I named the project FSlash since it's an F# inspired version of my previously written OSlash monad tutorial where I ported a number of Haskell abstractions to Python. I never felt that OSlash was really practically usable in Python, but F# is much closer to Python than Haskell, so it makes more sense to try and make a functional library inspired by F# instead.

Goals

• The resulting code should look and feel like Python. We want to make a better Python, not some obscure DSL or academic Monad tutorial
• Provide pipelining and pipe friendly methods.
• Dot-chaining on objects as an alternative syntax to pipes.
• Avoid currying, not supported in Python by default and not a well known concept by Python programmers.
• Avoid operator (|, >>, etc) overloading, this usually confuses more than it helps.
• Use type-hints for all functions and methods.
• Code should pass static type checking by tools such as mypy and pylance.

Non Goals

• Provide all features of F# and .NET to Python, see Supported Features.

Supported features

FSlash will never provide you with all the features of F# and .NET. We are providing a few of the features we think are useful, and will add more on-demand as we go along.

• Options - for optional stuff and better None handling.
• Result - for better error handling and enables railway-oriented programming in Python.
• Sequences - a better itertools
• Computational Expressions:
  • option - an optional world for working with optional values
  • result - an error handling world for working with result values
• Pattern matching - provided by Pampy.

Pipelining

OSlash provides a pipe function similar to |> in F#. We don't want to overload any Python operators e.g | so pipe is a plain old function taking N-arguments and thus lets you pipe a value though any number of functions.

gn = lambda g: g * y
fn = lambda x: x + z
value = pipe(x, fn, gn)

assert(value == gn(fn(x)))

Options

The option type is used when an actual value might not exist for a named value or variable. An option has an underlying type and can hold a value of that type Some(value), or it might not have the value Nothing.

from fslash import Some, Nothing

def keep_positive(a: int) -> Option[int]:
    if a > 0:
        return Some(a)
    else:
        return Nothing

from pampy import match

def exists (x : Option[int]) -> bool:
     return match(
          x,
          Some, lambda some: True
          Nothing, False
     )

Options as decorators for computational expressions. Computational expressions in OSlash are implemented as coroutines (enhanced generators) using yield, yield from and return to consume or generate optional values:

from fslash import option

@option
def fn():
     x = yield 42
     y = yield from Some(43)

     return x + y

xs = fn()

This enables "railway oriented programming" e.g if one part of the function yields from Nothing then the function is side-tracked (short-circuit) and the following statements will never be executed. The end result of the expression will be Nothing. Thus results from such a option decorated function can either be Ok(value) or Error(error_value).

from fslash import option

@option
def fn():
     x = yield from Nothing # or a function returning Nothing

     # -- The rest of the function will never be executed --
     y = yield from Some(43)

     return x + y

xs = fn()
assert xs is Nothing

Results

The Result[T,TError] type lets you write error-tolerant code that can be composed. Result works similar to Option but lets you define the value used for errors, e.g an exception type or similar. This is great when you want to know why some operation failed (not just Nothing).

Sequences

Contains operations for working with iterables.

Resources

• F# (http://fsharp.org)
• Get Started with F# (https://aka.ms/fsharphome)
• F# as a Better Python - Phillip Carter - NDC Oslo 2020 (https://www.youtube.com/watch?v=_QnbV6CAWXc)
• Pampy: Pattern Matching for Python (https://github.com/santinic/pampy)
• OSlash (https://github.com/dbrattli/OSlash)
• RxPY (https://github.com/ReactiveX/RxPY)
• PEP 342 -- Coroutines via Enhanced Generators (https://www.python.org/dev/peps/pep-0342/)

How-to Contribute

You are welcome to contribute with PRs. Any code should be aligned with F# modules, functions and documentation. Code, doc-strings and comments should also follow the Google Python Style Guide.

License

MIT, see LICENSE.