C#

public static bool TryParse(string s, out int result)

out<\out>.  Would you say that a fair example is in functions that accept user inputs and can throw or rethrow several different exceptions of which only a couple represent an actual problem and the rest of them represent errors in the user's input that can be safely swallowed within the function?<br />
<div class="signature">if (Object.DividedByZero == true) { Universe.Implode(); }<br />
Meus ratio ex fortis machina.  Simplicitatis de formae ac munus. -Foothill, 2016</div>

try
{
  // code that throws an exception
}
catch (Exception)
{
  return false;
}

try
{
  // code that throws an exception
}
catch
{
  return false;
}

private int GetForSomeReason(List<MyClass> mc, out List<MyClass> result, string somethingToLookFor)
   {
   ...

int total = GetForSomeReason(myList, out listOfJoes, "joe") + GetForSomeReason(myList, out listOfMikes, "mike");

public class Parse<T>
{
  public bool HasValue;
  public T Value;
}

Parse<int> value = int.TryParse("12");
if (!value.HasValue) return;
DoSomething(value.Value);

Pete O'Hanlon wrote:

While this may seem to be a reasonable solution, on the surface, there are several issues with this design. The biggest problem I have with it is that you are allocating a larger object than you need to. Even if we were to change this to a struct, it's still an unreasonably large surface area for a simple value.

public class Parse<T>
{
  bool HasValue { get; set; }
  T Value { get; set; }
  string AdditionalInformation { get; set; }
}

public abstract class Parse<T>
{
    public abstract bool HasValue { get; }
    public abstract T Value { get; }
    public abstract string AdditionalInformation { get; }
    
    private sealed class ParseSome : Parse<T>
    {
        public ParseSome(T value)
        {
            Value = value;
        }
        
        public override bool HasValue => true;
        public override string AdditionalInformation => null;
        public override T Value { get; }
    }
    
    private sealed class ParseNone : Parse<T>
    {
        public ParseNone(string additionalInformation)
        {
            AdditionalInformation = additionalInformation;
        }
        
        public override bool HasValue => false;
        public override string AdditionalInformation { get; }
        
        public override T Value
        {
            get { throw new InvalidOperationException(AdditionalInformation); }
        }
    }
    
    public static Parse<T> Some(T value)
    {
        return new ParseSome(value);
    }
    
    public static Parse<T> None(string additionalInformation)
    {
        return new ParseNone(additionalInformation);
    }
}

// Let's say that you run a search to see if a particular product was on sale
public bool IsProductOnSale(guid productId, out Guid[] productResellerIds)
{
  // This function runs a query against the database to see if this particular product has references in the 'on sale' reference table.
  // If it has references, it returns true also sets the array of resellers that sell that product.
  // The data for which seller has the item on sale is returned in the product query.
}

class Product
{
    private Collection<Seller> resellers;
    public Collection<Seller> Resellers
    {
        if (null == resellers)
        {
           // Do your look-up, and set resellers accordingly (using interlock if necessary)
        }
        return resellers;
    }

    public bool IsProductOnSale()
    {
        return (Resellers.Count > 0);
    }

    // ...
}