Welcome to the Lounge

honey the codewitch wrote:

does this refer to an invocation of the method foo? or an invocation of the delegate instance referred to by the variable or argument foo?

honey the codewitch wrote:

That's why I adopt different naming styles and even coding guidelines depending on context. My C++ library code uses different conventions than my other C++ code which uses different conventions

honey the codewitch wrote:

C# code which uses different conventions than my java code, etc. My XML naming styles are different depending on context, and json naming style tends to be camelCase

int a(int x) { return x + 1; }

auto b = [](int y) -> int { return y + 1; };

struct C {
  int operator()(int z) const { return z + 1; }
};
C c;

class D {
  int d(int x) const { return x + 1; }
  static int e(int x) { return x + 1; }
public:
  void do_stuff(int a_number) {
    a_number = a(a_number);
    a_number = b(a_number);
    a_number = c(a_number);
    a_number = d(a_number);
    a_number = e(a_number);
    y = a_number;
  }

  int y;
};

template<uint32_t Offset, uint32_t Size>
struct bit_field_t {
  :         :
// Other methods
  :         :
   auto get_value(uint32_t from_field) {
      if constexpr (Size == 1) {
         // Return a Boolean if Size == 1
         return (field & (1<<Offset)) == (1<<Offset);
      }
      // Return a uint32_t if Size != 1
      else {
         return (field>>Offset) & ((1<<Size)-1);
      }
   }
};

let rec fac (n:int): int = 
    match n with
    | 1 -> 1
    | x -> x * fac x

(* even and odd are inferred to have type int -> int *)
let rec even n =
    match n with
    | 0 -> true
    | x -> odd (x-1)
  and odd n =
    match n with
    | 0 -> false
    | x -> even (x-1)

using static System.Console;
namespace MyNamespace
{
	class Program
	{
		private delegate void WriteLineFunc();
		private static WriteLineFunc WriteLine;

		static void Main(string[] args)
		{
			WriteLine();// delegate is used
		{
	{
}

foo

Foo("bar");