Dup-Form 1: Fill & Download for Free

No. The Tories are not anywhere near as popular as the question suggests.The question suggests that the Tories must be ‘very popular’ because the electoral map of England appears almost completly blue.The maps below shows why this isn’t the case: Labour is mostly popular in small, densely-populated constituencies. The Conservatives are mostly popular in large sparsely-populated consituencies.In the geographic view it indeed appears that almost the entirity of England voted for the Conservative Party.But, when the map is adjusted so all constituencies are the same size, or by population, it quickly becomes clear that the conservatives are nowhere near as popular as they look in the geographic view.In fact the Conservatives got 42% of the vote, Labour got 40%, The Liberals got 7%, the SNP 3%, UKIP 2%, and the DUP 1%The Conservatives only got 2% more of the vote than Labour!However, because of the UK’s ‘First Past the Post’ electoral system, which rewards a concentrated vote, those percentages converted into 318 MPs for the Consevatives, 262 for Labour, 35 for the SNP, 12 for the Liberals 10 for the DUP, and none for UKIP.So, simply, the Conservative Party is nowhere near as popular in the country as as it appears on the geographic election mapThe question is right in mentioning people from the north of England and from Wales. Outside the south of England the Conservatives have very little support. They also have very little support in London. Hence it’s no wonder that people from those areas are heard complaining about the result.

Well this is going to be a big list XDThey hiked university tuition fees to £9000 a year.They put forward a referendum to pull us out of the EU, several Tory politicians took part in the campaign promoting blatant lies and then refused to take responsibility for it when they got their way by actually taking over from David Cameron and negotiating the deal with the EU.Theresa May didn’t bother attending the debates during her last election because they were so far ahead of Labour due to constant smearing of Jeremy Corbyn in the press. He closed a 20+% lead to force a hung parliament. After having her lackeys argue that Labour had a “magic money tree wish list” they then formed their government by paying the DUP £1 billion.Funding Hinkley Point C nuclear power plant instead of investing in wind and solar which is now cheaper.Putting forward the same Brexit deal 3 times and expecting a different result.Austerity. Particularly damaging if you have a minimum wage or gig economy job.No response to the above other than the token gestures expected of them.Lying about being progressive with Theresa May doing so even in her own resignation speech.The real question is, why do ANY young people vote for the UK Conservative party?

TL;DR: presumably, because people find naming things a really useful thing to do in most cases.Tacit/Pointfree style is more of a characteristic of concatenative programming languages, not functional ones. For example, you’d see the following kind of code in Factor:>> "ana" dup reverse = t  >> "not" dup reverse = f Which checks if a word is a Palindrome by only composing the functions “duplicate”, “reverse” and “equals”. We could also say that the name “palindrome?” means the composition of those three functions:>> : palindrome? ( string -- ? ) dup reverse = ; >> "ana" palindrome? t  >> "not" palindrome? f Incidentally, object oriented programming languages often compile to a stack-based machine. These stack-based machines have programs expressed in a tacit style. For example, here’s Python:# -- This code def reverse(s): return ''.join(reversed(s)) def palindrome(s): return s == reverse(s)  # -- Has this bytecode  1 0 LOAD_FAST 0 (string)  3 LOAD_GLOBAL 0 (reverse)  6 LOAD_FAST 0 (string)  9 CALL_FUNCTION 1  12 COMPARE_OP 2 (==) Which, if Python didn’t have a special handling for locals, would be shortened to “duplicate the top of the stack”, “load the reverse function”, “apply the reverse function”, “apply the == operator”. Just like in Factor.Now, JavaScript, and most other programming languages (including Haskell) are not concatenative. That means that if they ever exhibit function composition at this level, it’s most likely incidental. That’s not the intended way of describing programs.As for why, let’s look at what writing Fibonacci looks like when you can’t name your intermediate values:USING: kernel math combinators ;   : fib ( n -- n )  {  { [ dup 0 = ] [ ] }  { [ dup 1 = ] [ ] }  [ dup 1 - fib swap 2 - fib + ]  } cond ; Now, compare that to what you’d write in Haskell, if you were writing the same recursive definition:fib 0 = 0 fib 1 = 1 fib n = fib (n - 1) + fib (n - 2) At least for me, the version naming the values (the Haskell one) is much easier to follow, and reads almost like the inductive mathematical definition.You could write a recursive fibonacci definition that looks like the Factor one in Haskell if you wanted to. You could also write it in pretty much every other language that allows you to combine functions. However, I prefer to be able to name my intermediate values where it makes sense, rather than figuring out what’s happening by re-building the dataflow graph in my head. And I presume other people feel the same.edit: Here’s an example of what a tacit Fibonacci’d look like in JavaScript:// -- Combinators necessary for tacit style const compose = (f, g) => (x) => f(g(x))  const cond3 = ([f, ft], [g, gt], h) => (x) =>   f(x) ? ft(x) : g(x) ? gt(x) : h(x)   const fork = (f, g) => (x) => [f(x), g(x)]  const join = (f) => ([x, y]) => f(x)(y)  const eq = (x) => (y) => x === y  const add = (x) => (y) => x + y   const sub = (x) => (y) => x - y  const flip = (f) => (x) => (y) => f(y)(x)  const k = (x) => (_) => x  const lazyf = (f) => (x) => f()(x)   // -- The actual Fibonacci definition // (we need to wrap things in a `lazyf` combinator since // names are resolved eagerly in a call-by-value language) // const fib_ = lazyf(() => fib)  const fib = cond3(  [eq(0), k(0)],  [eq(1), k(1)],  compose(  join(add),  fork(compose(fib_, flip(sub)(1)), compose(fib_, flip(sub)(2)))  ) )  fib(9) // => 34 edit 2: Tacit programming does work pretty nicely for things that are naturally expressed as processing pipelines: build systems, request processing in HTTP servers, etc. I just feel like there’re more use cases where naming your intermediate values is a really great thing. I wouldn’t like that power to be taken away from me.Shell commands are a pretty common example of every-day tacit programming, after all, “ls | grep something” is just function composition.