_ = Some(hello{})
	res := Applicative2(func(a int, b int) int {
		return 0
	})
	_ = res
}

type NoneType[T any] struct{}

func (r NoneType[T]) Recover() any {
	return nil
}

type Func2[A1, A2, R any] func(a1 A1, a2 A2) R

func Some[T any](v T) any {
	_ = Some2[T](v)
	return NoneType[T]{}.Recover()
}

//go:noinline
func Some2[T any](v T) any {
	return v
}

type Nil struct{}

  EXPECT_EQ(it->getNumOperands(), 24);
  EXPECT_EQ(it->getNumResults(), 1);
  // cifg = false, so input2input is not None.
  EXPECT_FALSE(mlir::isa<NoneType>(it->getOperand(1).getType()));
  // input layer norm is None
  EXPECT_TRUE(mlir::isa<NoneType>(it->getOperand(20).getType()));
  // proj_bias is F32
  EXPECT_TRUE(mlir::cast<RankedTensorType>(it->getOperand(17).getType())
                  .getElementType()

def test_body_repr_list():
    assert repr(Body([])) == "Body([])"


def test_depends_repr():
    assert repr(Depends()) == "Depends(NoneType)"
    assert repr(Depends(get_user)) == "Depends(get_user)"
    assert repr(Depends(use_cache=False)) == "Depends(NoneType, use_cache=False)"
    assert (
        repr(Depends(get_user, use_cache=False)) == "Depends(get_user, use_cache=False)"

  NativeCodeCall<"TransposeLastTwoDims($0[0].getType())">;

def AreLastTwoDimsTransposed : Constraint<CPred<
  "TFL::AreLastTwoDimsTransposed($0)">>;

// Checks if the param passed is of NoneType.
def IsNoneType : Constraint<CPred<"$0.getType().isa<NoneType>()">>;

def ConstantLikePred : CPred<"::mlir::matchPattern($0, ::mlir::m_Constant())">;
def IsConstantLike : Constraint<ConstantLikePred>;

		return errMalformedXML(err)
	}

	parsedType := CompressionType(strings.ToUpper(s))
	if s == "" || parsedType == "NONE" {
		parsedType = noneType
	}

	switch parsedType {
	case noneType, gzipType, bzip2Type, snappyType, s2Type, zstdType, lz4Type:
	default:
		return errInvalidCompressionFormat(fmt.Errorf("invalid compression format '%v'", s))
	}

	*c = parsedType

    return failure();
  }
  lstm_variant->use_projection =
      !mlir::isa<NoneType>(op.getProjectionWeights().getType());
  lstm_variant->use_peephole =
      !mlir::isa<NoneType>(op.getCellToOutputWeights().getType());
  lstm_variant->use_layer_norm =
      !mlir::isa<NoneType>(op.getForgetLayerNormCoefficients().getType());

  *op_property = operator_property::GetOperatorProperty(

      SmallVector<Value, 4> inputs;
      inputs.reserve(candidate_op->getNumOperands());
      for (auto operand : candidate_op->getOperands()) {
        Type operand_type = operand.getType();
        if (mlir::isa<NoneType>(operand_type)) {
          inputs.push_back(operand);
          continue;
        }

        auto ele_type =
            mlir::cast<TensorType>(operand.getType()).getElementType();
        if (auto dq_op =

          TypeIsPred<"input_gate_bias", NoneType>,
          TypeIsPred<"input_layer_norm_coefficients", NoneType>]>,
     Neg<Or<[
       TypeIsPred<"input_to_input_weights", NoneType>,
       TypeIsPred<"recurrent_to_input_weights", NoneType>,
       TypeIsPred<"input_gate_bias", NoneType>]>>]>>;


// TODO(b/137798843): Need to add an additional constraint for both LSTM and

	}
	scannedReader := newCountUpReader(rc)
	pr := progressReader{
		rc:            rc,
		scannedReader: scannedReader,
	}
	var r io.Reader

	switch compType {
	case noneType:
		r = scannedReader
	case gzipType:
		gzr, err := gzip.NewReader(scannedReader)
		if err != nil {
			if errors.Is(err, gzip.ErrHeader) || errors.Is(err, gzip.ErrChecksum) {

      return failure();
    }

    Value filter = fc_op.getFilter();
    Value bias = fc_op.getBias();
    ElementsAttr bias_value;
    const bool is_none_bias = mlir::isa<NoneType>(bias.getType());
    if (fc_op.getFusedActivationFunction() != "NONE") return failure();

    if (!is_none_bias && !matchPattern(bias, m_Constant(&bias_value)))
      return failure();

    // Rewrite