Next code originally was a classic C code I've written, it's pure vertical thinking, now, I converted it successfully to D code, but I think I made no much changes to make it has more horizontal thinking style that it seems D programmers care in horizontal thinking style. Is there any additions I can make in the code to make it suitable with D style or it's fine?

// D programming language

import std.stdio;

int main()
{

int numbers[10]=[-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
char negativity,
      even;

write("Would you like in list (n=negatives, p=positives, b=both)? ");
readf(" %c", &negativity);

write("Would you like in list (e=evens, o=odds, b=both)? ");
readf(" %c", &even);

for(int i=0; i<10; ++i)
	{
	 if(negativity=='n')
	 	{
	 	if(numbers[i]>0)
	 		continue;
	 	}
	 else{
	  if(negativity=='p')
	  	if(numbers[i]<0)
	  		continue;
	  }
	
	  if(even=='e')
	 	{
	 	if(numbers[i]%2)
	 		continue;
	 	}
	 else{
	  if(even=='o')
	  	if(!(numbers[i]%2))
	  		continue;
	  }		
	 writefln("%d",numbers[i]);
	}
	
	
return 0;
}

On Tuesday, 2 November 2021 at 23:45:39 UTC, pascal111 wrote:

By "vertical" vs. "horizontal" thinking, do you mean imperative vs. functional style?
https://en.wikipedia.org/wiki/Functional_programming#Imperative_vs._functional_programming

It's supported in many modern programming languages and it's not a unique feature of the D language alone. Your code can be changed to something like this:

import std.stdio, std.algorithm, std.conv, std.string;

void main()
{
  auto numbers = [-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
  char negativity, even;

  write("Would you like in list (n=negatives, p=positives, b=both)? ");
  readf(" %c", &negativity);

  write("Would you like in list (e=evens, o=odds, b=both)? ");
  readf(" %c", &even);

  numbers.filter!(x => !((negativity == 'n' && x > 0) ||
                         (negativity == 'p' && x < 0)))
         .filter!(x => !((even == 'e' && (x % 2)) ||
                         (even == 'o' && !(x % 2))))
         .map!text.join("\n").writeln;
}

On Wednesday, 3 November 2021 at 00:50:51 UTC, Siarhei Siamashka wrote:

import std.stdio, std.algorithm, std.conv, std.string;

void main()
{
  auto numbers = [-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
  char negativity, even;

  write("Would you like in list (n=negatives, p=positives, b=both)? ");
  readf(" %c", &negativity);

  write("Would you like in list (e=evens, o=odds, b=both)? ");
  readf(" %c", &even);

  numbers.filter!(x => !((negativity == 'n' && x > 0) ||
                         (negativity == 'p' && x < 0)))
         .filter!(x => !((even == 'e' && (x % 2)) ||
                         (even == 'o' && !(x % 2))))
         .map!text.join("\n").writeln;
}

Wow! your code seem so nice, I like it although I don't know how exactly it works. For now I'll keep learning traditional imperative programming style then after that I'll look in the functional one, it's new to me.

On Wednesday, 3 November 2021 at 00:50:51 UTC, Siarhei Siamashka wrote:

Maybe you are right, I think that, but I don't know the exact English terms.

On Wednesday, 3 November 2021 at 00:50:51 UTC, Siarhei Siamashka wrote:

!text.join("\n").writeln;

Ahem... You've turned a program that does not allocate to a program that allocates who knows how much memory?

And Ali... associative arrays? For this? What are you trying to teach the good beginner here? :D

import std.stdio, std.algorithm;

void main()
{
  auto numbers = [-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
  char negativity, even;

  write("Would you like in list (n=negatives, p=positives, b=both)? ");
  readf(" %c", &negativity);

  write("Would you like in list (e=evens, o=odds, b=both)? ");
  readf(" %c", &even);

  if ((negativity == 'b') && (even == 'b'))
  {
      // don't do any unnecessary work
      numbers.each!writeln;
  }
  else
  {
      numbers.filter!(x => !((negativity == 'n' && x > 0) ||
                             (negativity == 'p' && x < 0)))
             .filter!(x => !((even == 'e' && (x % 2)) ||
                             (even == 'o' && !(x % 2))))
             .each!writeln;
  }
}

The code "as is" is perfectly fine

I don't understand why you guys offer OP such complicate/bloated examples, it'll only make things confusing and slow down compilation time with templates and imports, this is not needed at all

One change, use .length property instead of the hardcoded value

Keeping things simple helps debugging!

int main() {

  int numbers[10] = [-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
  char negativity, even;
  write("Would you like in list (n=negatives, p=positives, b=both)? ");
  readf(" %c", & negativity);

  write("Would you like in list (e=evens, o=odds, b=both)? ");
  readf(" %c", & even);

  // you can access .length property of slices/arrays/static_arrays in D
  for (int i = 0; i < numbers.length; ++i) {
    if (negativity == 'n') {
      if (numbers[i] > 0)
        continue;
    } else {
      if (negativity == 'p')
        if (numbers[i] < 0)
          continue;
    }

    if (even == 'e') {
      if (numbers[i] % 2)
        continue;
    } else {
      if (even == 'o')
        if (!(numbers[i] % 2))
          continue;
    }
    writefln("%d", numbers[i]);
  }

  return 0;
}

On Wednesday, 3 November 2021 at 20:36:08 UTC, russhy wrote:

I don't like complicated things either. Additional facilities are interminable in D :)

For example:

import std.stdio, std.algorithm, std.array;

int main() {
	auto numbers = [-3, 14, 47, -49, -30, 15, 4, -82, 99, 26];
	char negativity, even;

Start:
	bool error;

 	enum sign { negatives = 'n', positives = 'p', both = 'b' }
	write("Would you like in list (n=negatives, p=positives, b=both)? ");
	readf(" %c", &negativity);

	switch (negativity) with(sign) {
		case negatives:
			numbers = filter!("a < 0")(numbers).array;
			break;
		case positives:
			numbers = filter!("a > 0")(numbers).array;
			break;
		case both:
		break;
		default:
			error = true;
			goto Error;
	}
	
	enum type { evens = 'e', odds = 'o', both = 'b' }
	write("Would you like in list (e=evens, o=odds, b=both)? ");
	readf(" %c", &even);

	switch (even) with(type) {
		case evens:
			numbers = filter!("!(a % 2)")(numbers).array;
			break;
		case odds:
			numbers = filter!("a & 1")(numbers).array;
			break;
		case both:
		break;
		default:
			error = true;
	}

Error:
	if(error) {
		"Error...".writeln;
		goto Start;
	} else writef("%(%s\n%)", numbers);

	return 0;
}

Please try to use auto...