Documentation

Builds a Python argument from any Haskell type with a ToPy instance

FromPy instances indicate that a type can be marshalled from Python to Haskell automatically

For example, FromPy Integer indicates that we know how to take some Python object and convert it into a Haskell Integer. If the Python object is int, then we can cast properly. Failed casts throw a PyCastException

An exception representing a failed cast from a Python object to Haskell value, usually because the expected type of the Python object was not correct.

Carries a String which represents the name of the expected Haskell type which caused a failed cast. If using easyFromPy, this String is found with typeRep

ToPy instances indicate that a type can be marshalled from Haskell to Python automatically

For example, ToPy Integer indicates that we know how to take a Haskell Integer and convert it into a Python int object

The most common use case of Simple is calling some Python function

For example, if we wanted to wrap Python's random.randint(low, high), we could write this:

randint :: Integer -> Integer -> IO Integer
randint low high =
  call "random" "randint" [arg low, arg high] []

Because of the FromPy instance in call's type signature, we can infer what to do to convert a Python value back into Haskell, if given the type. In this example using random.uniform, although we use a similar definition as for randint, we correct cast to Double instead of Integer

uniform :: Integer -> Integer -> IO Double
uniform low high =
  call "random" "uniform" [arg low, arg high] []

We can also use the TypeApplications language extension to tell call what type to use, if needed

call @Double "random" "uniform" [arg low, arg high] []

Calling a function with mixed positional and keyword arguments is also fairly straightforward.

The example is equivalent to calling pyautogui.moveTo(x, y, duration=seconds)

moveToDuration :: Integer -> Integer -> Double -> IO ()
moveToDuration x y seconds =
  call "pyautogui" "moveTo" [arg x, arg y] [("duration", arg seconds)]

Helper that takes a conversion function and a Python object, and casts the Python object into a Haskell value.

Lets you define fromPy with just a Python conversion function

We use Proxy to infer the type name for use in case of a failed cast. In the context of defining an instance, this type will be inferrable, so you can just provide a Proxy value

Helper that lets you convert a Haskell value to a Python object by providing both a Python conversion function (from the Haskell type, over FFI, to some Python Object) as well as the Haskell value

Lets you define toPy with just a Python conversion function

Get the value of an attribute of some Python module

This example is equivalent to getting random.BPF in Python

getBpf :: IO Integer
getBpf = getAttribute "random" "BPF"

Given a Python module name as text, imports it as a Module

Throws an exception if e.g. the module name was misspelled, or isn't installed

Kicks off talking to Python, and will need to be called before using other functions

Set the value of an attribute of some Python module

This example is equivalent to setting random.BPF = n in Python

setBpf :: Integer -> IO ()
setBpf n = setAttribute "random" "BPF" n