"Anonymous function converted to a void returning delegate cannot return a value" trying to return a value from Option.Match

[MrYossu]

As usual, I'm sure this is really obvious to the enlightened, but I'm not, so please humour me!

I have a method that creates a folder in Google Drive. That works fine, but the current version doesn't check if a folder of the same name exists, and will create another with the same name. I know Google allows this, but my requirement is not to.

So, I want to change my method to check if a folder exists with the given name, and if so, return the Id of that folder. If a folder doesn't exist, then we'll create a new one and return the Id of the new folder.

I have an existing method that gets the subfolders of a specified folder...

public async Task<Option<List<DriveFile>>> GetSubfolders(string folderId)

This returns Some<List<DriveFile>> if a folder exists with the Id of folderId and None<List<DriveFile>> if not.

I was expecting to be able to use this as follows...

public async Task<Option<string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  (await GetSubfolders(parentFolderId))
  .Match(async folders => {
    if (folders.Any()) {
      return folders.First().Id;
    }
    // The implementation of CreateNewFolder isn't shown as it's not relevant to my question
    DriveFile folder = await CreateNewFolder(folderName, parentFolderId);
    return folder.Id;
  }, () => {
    return Option<string>.None;
  });

However, I get compiler errors on the three return lines...

Anonymous function converted to a void returning delegate cannot return a value

I've done some searching on this error, but don't really understand what's going on here. I have returned values from Match before, and not had this issue.

Anyone able to explain what I'm doing wrong? Thanks.

Update If I extract the code that does the actual folder creation to a separate method as follows...

public async Task<Option<string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  (await GetSubfolders(parentFolderId))
  .Match(async folders => await CreateNewFolder(folderName, parentFolderId, folders), Option<string>.None);

...then I'm down to one compiler error on the Option<string>.None at the end...

Argument 2: cannot convert from 'LanguageExt.Option' to 'System.Func<System.Threading.Tasks.Task>'

OK, so let's change the code to this...

public async Task<Option<string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  (await GetSubfolders(parentFolderId))
  .Match(async folders => await CreateNewFolder(folderName, parentFolderId, folders), () => Option<string>.None);

That changes the compiler error to...

Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement

So I'm baffled.

[louthy]

If the compiler infers that Match(Action, Action) (the void returning version of match) when you're actively trying to return a value, then the two functions (Some: and None:) don't have a common-type, or the common-type can't be inferred by the compiler.

In this case you have a Task<Option<string>> and a Option<string>. There is nothing the compiler can do to infer those as the same, as there's no common join between them.

If you instead use this on your None branch: () => Option<string>.None.AsTask() or Option<string>.None.AsTask() then it should work.

Note also, that if you're calling Match and each branch returns an Option, then you're effectively doing a Bind. This will probably work too:

public async Task<Option<string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  GetSubfolders(parentFolderId)
      .BindT(folders => CreateNewFolder(folderName, parentFolderId, folders));

I'm using BindT because it's two monads nested, so this runs the monadic bind operation for both the outer Task<> and the inner Option<>

[MrYossu]

@louthy Thanks for the reply and the explanation, but unfortunately your suggestions didn't work.

If I change the None branch to () => Option<string>.None.AsTask() then I get a compiler error on the whole method...

Cannot implicitly convert type 'LanguageExt.Unit' to 'LanguageExt.Option'

If I change it to just Option<string>.None.AsTask() then I get a compiler error on the None branch...

Argument 2: cannot convert from 'System.Threading.Tasks.Task<LanguageExt.Option>' to 'System.Func<System.Threading.Tasks.Task>'

If I copy your BindT code, then I get a compiler error on just the BindT itself...

The type arguments for method 'OptionT_AsyncSync_Extensions.BindT<A, B>(Task<Option>, Func<A, Option>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

Any idea what's going wrong?

To make it easier to understand, I've produced some dummy methods and a stripped-down version of the DriveFile class (which is what represents the folder in Google Drive) that simulate what's going on in the real code...

async Task<string> CreateNewFolder(string folderName, string parentFolderId, List<DriveFile> folders) {
  if (folders.Any()) {
    // Folder already exists with that name so return the Id
    return folders.First().Id;
  }
  // In reality we would create a folder here and return its Id
  return "new";
}

// In reality we check if a folder exists with the specified Id, and if not return `None`
// For simplicity, we'll just return `Some`
async Task<Option<List<DriveFile>>> GetSubfolders(string folderId) =>
  Option<List<DriveFile>>.Some(new List<DriveFile> { new DriveFile("Jim") });

class DriveFile { 
  public DriveFile(string id) =>
    Id = id;
  public string Id { get; set; }
}

Any chance you could show me how the CreateFolder method should look?

Here's what I have so far (before implementing any of your suggestions)...

public async Task<Option<string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  (await GetSubfolders(parentFolderId))
  .Match(async folders => await CreateNewFolder(folderName, parentFolderId, folders), Option<string>.None);

Thanks again.

P.S. Apologies about the bold text after the third exception. Not sure why it did that.

[MrYossu]

@louthy Just as an after-thought, am I even doing this the right way? I have a few similar functions, which return an Option<T>, where I'm returning Some if the call succeeded, and None if it failed, say an invalid folder Id was passed, or an exception was thrown when the call was made

It occurred to me that Option<T> probably isn't the most suitable monad to use here, and rewrote one to use Either<T1, T2> instead, as I think that's intended for handling exceptions. However, there's also TryAsync<T>, which seems to be intended for async operations that may fail. Well, making calls to Google Drive (or I guess any 3rd-party remote API) falls into that category.

Which do I use? Or should I be using something else entirely?

Please could you show me how to create my CreateFolder method using the most appropriate monad instead.

Thanks again.

[StefanBertels]

Some examples (pseudo code, might have typos).

// given: string CreateFolder(string path) ... which raises an exception on errors

var x1= Try(() => CreateFolder(path));  // catch Exception (when evaluated)
var x1evaluateNow = x1.Strict(); // eval now
Either<Exception, string> x2 = x1.ToEither(); // eval and store into Either
Either<Error, string> x2b = x2.MapLeft(Error.New); // map left value using some function
Option<string> x3 = x2.ToOption();

Look at the return values and look at the methods of those types. You can call .Match(...) on them to extract the result (good path) but you should avoid this (or at least delay this). Try to stay in those types (use .Map(...) or .Bind(...)). This will carry on exceptions to your result.

[MrYossu]

@StefanBertels Thanks for the reply. I re-thought out what I am trying to do, and realised that I was doing it wrong anyway. I have something that now works, please can you tell me if you think this looks sensible...

async Task<Either<Exception, string>> CreateFolder(string folderName, string parentFolderId = "root") =>
  await (await GetSubfolders(parentFolderId))
    .Match(async folders => await CreateNewFolder(folderName, parentFolderId, folders), ex => throw ex);

async Task<Either<Exception, string>> CreateNewFolder(string folderName, string parentFolderId, List<DriveFile> folders) {
  if (folders.Any()) {
    // Folder already exists with that name so return the Id
    return folders.First().Id;
  }
  // In reality we would create a folder here and return its Id. Creating a folder could throw an exception
  return "new";
}

async Task<Either<Exception, List<DriveFile>>> GetSubfolders(string folderId) {
  // Simulate what would happen if we passed a blank (or invalid) Id to Google Drive
  if (folderId == "") {
    throw new ArgumentException($"Invalid folderId: {folderId}");
  }
 return new List<DriveFile>(new List<DriveFile> { new DriveFile("Jim"), new DriveFile("John") });
}

Can this be improved at all? Thanks