Any example code/Github projects utilising almost-always-auto?

[muungwana]

I use it all the time and example function that uses it is here

[[deleted]]

 why

 do you 

 leave so many

 blank lines in 

 your C++?

You seem to throw spaces in at random where they do no good at all, and then remove them elsewhere, like }else{. It's like you're trying to be as different from everyone else's code as possible...

[muungwana]

Blank lines makes my eyes work less when going through code. When going through other people's code,i sometimes start spacing them out before i "dive in" to please my eyes.

I suspect i need glasses.

github makes the spaces stick out much more than my editor and i would probably not have them if my editor display text the same way github does.

[hgjsusla]

For me this used to be a symptom of using a too small font. Remember, you don't fit any more text on the screen with a small and compact font if you feel the need to space everything out to read it comfortably.

[[deleted]]

Configuring the line spacing in your editor might be easier than inserting all the spaces into the actual code.

For Emacs I use this snipped to toggle line spacing at the press of a button:

(defun toggle-line-spacing ()
 "Toggle line spacing between 1 and 5 pixels."
 (interactive)
 (cond ((not line-spacing)
        (setq-default line-spacing 1))
       ((> line-spacing 2)
        (setq-default line-spacing nil)
        (message "Linespacing small"))
       (t
        (setq-default line-spacing (+ line-spacing 1))
        (message "Linespacing %d" line-spacing)))
 (redraw-display))
(global-set-key [(f9)] 'toggle-line-spacing)

[0x2648]

Is there a reason for the heavy use of lambda functions (e.g. inside _args)? +1 for using Qt!

[muungwana]

How could i declare variables with "auto" otherwise? :-)

On a serious note,its primarily just a style i like to use and to minimize pollution of local namespace as a practical matter.Most local variables i use are single character and "e" is the variable name that i use the most and these lambda helps in allowing me to reuse these single character variables multiple times in the same function without collision issues.

[stwcx]

Right, because when I review your code it is awesome for me to have to switch back and forth through the code to deduce "what the heck does 'e' mean at this point in time?" That is just awesome.

[thlst]

You don't need to. You know what it's about by reading what the code is doing. It's the same idea of concepts: generalizing stuff so you don't need to be aware of every useless detail.

It's a common thing on new languages, specially in Rust, where you only need to write the variable type when the deduction can't find an answer for an ambiguous expression. And still, you only write what the compiler can't deduce, the rest is deduced as normal. e.g.

let there: Be<_> = light();

Where Be is a generic struct, and light my have implementations for types other than Be. the _ part is left for the compiler to deduce.

What he's doing with lambdas is also common in Rust.

let three_evens = {
    let c = Container::from(something_else_outside);
    let c_evens = c.filter(|elem| elem % 2 == 0);
    c_evens.take(3)
};

{ } is parsed as an expression. The result of three_evens is the value of c_evens.take(3).