Why The Monad Pattern Looks Promising in Go+Torch Design about gotorch HOT 6 CLOSED

type Torch struct {
    err error
    tensors []Tensor
}

func (torch *Torch) Error() error {
    return torch.err
}

func (torch *Torch) Reclaim()  {
    for t := torch.tensors {
        Delete(t)  // `Delete` is a imaginary cgo wrapper function that calls C++ delete
    }
    torch.tensors = []Tensor{}
}

func (torch *Torch) Relu(tensor Tensor) Tensor {
    if torch.err != nil {
        return Tensor{}
    }
    t, err := C.relu(tensor) // `C.relu` is the imaginary cgo wrapper function
    if err != nil {
        torch.err = err // Record line number etc.
        return Tensor{}
    }
    append([]Tensor{t}, torch.tensors...) // Register `Tensor`s in reverse order for later reclaiming
    return t
}

// Define `MaxPool2d`, `Dropout`, and other functions with a similar pattern as `Relu`

struct Net {
    torch.Torch
    // Define conv1, conv2, fc1, fc2 etc.
}

func (net *Net) Forward(x torch.Tensor) torch.Tensor {
    x = net.Relu(net.MaxPool2d(net.conv1.Forward(x), 2))
    x = net.Relu(
        net.MaxPool2d(net.conv2_drop.Forward(net.conv2.Forward(x)), 2))
    x = x.View([]int{-1, 320})
    x = net.Relu(net.fc1.Forward(x))
    x = net.Dropout(x, /*p=*/0.5, /*training=*/is_training())
    x = net.fc2.Forward(x)
    return net.LogSoftmax(x, /*dim=*/1)

// We need this nested function to make `defer` works as expected.
func step(batch *Batch) {
    // `model` is an instance of  the `Net` struct above
    defer model.Reclaim() // `delete` all tensors at the end of scope as the C++ version
    data := model.ToDevice(batch.Data, device)
    target := model.ToDevice(batch.Target, device)
    optimizer.zero_grad()
    output := model.Forward(data)
    loss = model.NllLoss(output, targets)
    loss.Backward()
    optimizer.Step()
    // ...
}

for batch := range data_loader {
    step(batch)
    if model.err != nil {  // Use the monad API to handle errors
        return ...
    }
}

struct Monad {
    err error
    tensors []Tensor
}

func (m *Monad) Get(func f() (Tensor, error)) Tensor {
    if m.err != nil {
        return Tensor{}
    }
    t, e := f()
    if e != nil {
        m.err = e
        return Tensor{}
    } 
    append([]Tensor{t}, tensors...)
    return t
}

func (m *Monad) Do(func f() error) {
    if m.err != nil {
        return Tensor{}
    }
    t, e := f()
    if e != nil {
        m.err = e
    } 
}

func (m *Monad)Error() error {
    return m.err
}

func (m *Monad) Reclaim() {
    for t := range tensors {
        C.Delete(t)
    }
}

for batch := range data_loader {
    var m torch.Monad
    defer m.Reclaim() // `delete` all tensors at the end of scope as the C++ version
    // `model` is an instance of  the `Net` struct above
    data := m.Get(=>model.ToDevice(batch.Data, device))
    target := m.Get(=>model.ToDevice(batch.Target, device))
    m.Do(=>optimizer.zero_grad())
    output := m.Get(=>model.Forward(data))
    loss = m.Get(=>model.NllLoss(output, targets))
    m.Do(=>loss.Backward())
    m.Do(=>optimizer.Step())
    if m.err != nil {  // Use the monad API to handle errors
        return ...
    }
}