Tidy up.

jtomschroeder · Aug 17, 2016 · ad1974a · ad1974a
1 parent 7c0559b
commit ad1974a
Show file tree

Hide file tree

Showing 17 changed files with 39 additions and 36 deletions.
diff --git a/demo/euler.cpp b/demo/euler.cpp
@@ -103,17  103,20 @@ PROBLEM(E6) {
 let prime = [](auto x) {
     if (x == 2) {
         return true;
-    } else if (x < 2 || even(x)) {
     }
 
     if (x < 2 || even(x)) {
         return false;
-    } else {
-        using I = std::remove_reference_t<std::remove_const_t<decltype(x)>>;
-        for (I i = 3, end = sqrt(x); i <= end; i  = 2) {
-            if (multipleOf(i, x)) {
-                return false;
-            }
     }
 
     using I = std::remove_reference_t<std::remove_const_t<decltype(x)>>;
     for (I i = 3, end = sqrt(x); i <= end; i  = 2) {
         if (multipleOf(i, x)) {
             return false;
         }
-        return true;
     }
     return true;
 
 };
 
 // What is the 10,001st prime number?

diff --git a/demo/problem.hpp b/demo/problem.hpp
@@ -7,7  7,7 @@
 
 struct Problem {
     static std::vector<std::function<void()>> problems;
-    Problem(std::function<void()> p) { problems.push_back(p); }
     explicit Problem(std::function<void()> p) { problems.push_back(p); }
 };
 
 std::vector<std::function<void()>> Problem::problems;

diff --git a/lib/lambda/apply.hpp b/lib/lambda/apply.hpp
@@ -10,7  10,7 @@ namespace lambda {
 
 namespace detail {
 template <class F, class Tuple, std::size_t... I>
-constexpr auto apply(F &&f, Tuple &&t, std::index_sequence<I...>) {
 constexpr auto apply(F &&f, Tuple &&t, std::index_sequence<I...> /*unused*/) {
     return invoke(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
 }
 }

diff --git a/lib/lambda/curry.hpp b/lib/lambda/curry.hpp
@@ -3,8  3,8 @@
 
 #include "type_traits.hpp"
 
-#include <tuple>
 #include <functional>
 #include <tuple>
 
 namespace lambda {
 
@@ -25,12  25,12 @@ struct Curried {
     }
 
     template <std::size_t... Ns, typename... Ts>
-    auto call(std::index_sequence<Ns...>, Ts &&... ts) const {
     auto call(std::index_sequence<Ns...> /*unused*/, Ts &&... ts) const {
         return dispatch(std::get<Ns>(args)..., std::forward<Ts>(ts)...);
     }
 
 public:
-    Curried(F f, BoundArgs &&... args) : f(f), args(std::forward<BoundArgs>(args)...) {}
     explicit Curried(F f, BoundArgs &&... args) : f(std::move(f)), args(std::forward<BoundArgs>(args)...) {}
 
     template <typename... Ts>
     auto operator()(Ts &&... ts) const {

diff --git a/lib/lambda/dollar.hpp b/lib/lambda/dollar.hpp
@@ -10,8  10,8 @@ constexpr std::vector<std::common_type_t<Ts...>> vector(Ts &&... ts) {
 }
 
 template <class... Ts>
-constexpr auto array(Ts &&... ts) {
-    return std::array<std::common_type_t<Ts...>, sizeof...(ts)>{std::forward<Ts>(ts)...};
 constexpr auto array(Ts &&... ts) -> std::array<std::common_type_t<Ts...>, sizeof...(ts)> {
     return {std::forward<Ts>(ts)...};
 }
 
 } /* factory */

diff --git a/lib/lambda/function_traits.hpp b/lib/lambda/function_traits.hpp
@@ -1,8  1,8 @@
 
 #pragma once
 
-#include <type_traits>
 #include <array>
 #include <type_traits>
 
 namespace lambda {
 

diff --git a/lib/lambda/printer.hpp b/lib/lambda/printer.hpp
@@ -14,7  14,7 @@ class Printer {
         return p;
     }
 
-    Printer() {}
     Printer() = default;
 
     Printer &operator<<(std::string s) {
         std::cout << s;

diff --git a/lib/lambda/stream/drop.hpp b/lib/lambda/stream/drop.hpp
@@ -16,7  16,7 @@ class DropStream : public Stream {
 public:
     using Type = typename S::Type;
 
-    DropStream(S stream, I num) : stream(stream), num(num), flag(new std::once_flag) {}
     DropStream(S stream, I num) : stream(std::move(stream)), num(num), flag(new std::once_flag) {}
 
     Maybe<Type> next() {
         std::call_once(*flag, [&]() {
@@ -36,7  36,7 @@ class Drop : public Pipeable {
     const I num;
 
 public:
-    Drop(I num) : num(num) {}
     explicit Drop(I num) : num(num) {}
 
     template <class S>
     auto pipe(S stream) const {

diff --git a/lib/lambda/stream/filter.hpp b/lib/lambda/stream/filter.hpp
@@ -14,7  14,7 @@ class FilterStream : public Stream {
 public:
     using Type = typename S::Type;
 
-    FilterStream(S stream, F fn) : stream(stream), fn(fn) {}
     FilterStream(S stream, F fn) : stream(std::move(stream)), fn(std::move(fn)) {}
 
     Maybe<Type> next() {
         while (auto s = std::move(stream.next())) {
@@ -31,7  31,7 @@ class Filter : public Pipeable {
     F f;
 
 public:
-    Filter(F f) : f(f) {}
     explicit Filter(F f) : f(std::move(f)) {}
 
     template <class S>
     auto pipe(S stream) const {

diff --git a/lib/lambda/stream/fold.hpp b/lib/lambda/stream/fold.hpp
@@ -1,7  1,7 @@
 
 #pragma once
 
-#include "stream.hpp"
 #include "lambda.hpp"
 
 namespace lambda {
 namespace streams {

diff --git a/lib/lambda/stream/generator.hpp b/lib/lambda/stream/generator.hpp
@@ -13,7  13,7 @@ class Generator : public Stream {
 public:
     using Type = std::result_of_t<decltype(std::declval<G>)>;
 
-    Generator(G gen) : gen(gen) {}
     explicit Generator(G gen) : gen(std::move(gen)) {}
 
     Maybe<Type> next() { return some(gen()); }
 };

diff --git a/lib/lambda/stream/ints.hpp b/lib/lambda/stream/ints.hpp
@@ -37,7  37,7 @@ class IntsStream : public Stream {
 public:
     using Type = I;
 
-    IntsStream(I begin) : begin(begin) {}
     explicit IntsStream(I begin) : begin(begin) {}
 
     Maybe<Type> next() { return some(begin  ); }
 };

diff --git a/lib/lambda/stream/map.hpp b/lib/lambda/stream/map.hpp
@@ -14,7  14,7 @@ class MapStream : public Stream {
 public:
     using Type = typename S::Type;
 
-    MapStream(S stream, F fn) : stream(stream), fn(fn) {}
     MapStream(S stream, F fn) : stream(std::move(stream)), fn(fn) {}
 
     Maybe<Type> next() { return std::move(stream.next()) >> fn; }
 };
@@ -24,7  24,7 @@ class Map : public Pipeable {
     F f;
 
 public:
-    Map(F f) : f(f) {}
     explicit Map(F f) : f(f) {}
 
     template <class S>
     auto pipe(S stream) const {

diff --git a/lib/lambda/stream/mod.hpp b/lib/lambda/stream/mod.hpp
@@ -16,7  16,7 @@
 #include "fold.hpp"
 
 //
-// TODO:
 // TODO(jtomschroeder): 
 // - max: (fold?)
 // - drop (change to 'skip')
 // - list comprehension

diff --git a/lib/lambda/stream/stream.hpp b/lib/lambda/stream/stream.hpp
@@ -22,7  22,7 @@ class CollectionStream : public Stream {
 public:
     using Type = typename C::value_type;
 
-    CollectionStream(C &&collection)
     explicit CollectionStream(C &&collection)
         : collection(collection), begin(collection.cbegin()), end(collection.cend()) {}
 
     Maybe<Type> next() { return begin != end ? some(std::move(*begin  )) : none; }
@@ -40,7  40,7 @@ class FunctionStream : public Stream {
 public:
     using Type = typename std::result_of_t<decltype(std::declval<F>)>::value_type; // Maybe::Type
 
-    FunctionStream(F &&f) : f(f) {}
     explicit FunctionStream(F &&f) : f(f) {}
 
     Maybe<Type> next() { return f(); }
 };

diff --git a/lib/lambda/stream/take.hpp b/lib/lambda/stream/take.hpp
@@ -25,7  25,7 @@ class Take : public Pipeable {
     const I num;
 
 public:
-    Take(I num) : num(num) {}
     explicit Take(I num) : num(num) {}
 
     template <class S>
     auto pipe(S stream) const {
@@ -48,14  48,14 @@ class TakeWhileStream : public Stream {
 public:
     using Type = typename S::Type;
 
-    TakeWhileStream(S stream, P pred) : stream(stream), pred(pred) {}
     TakeWhileStream(S stream, P pred) : stream(std::move(stream)), pred(std::move(pred)) {}
 
     Maybe<Type> next() {
         if (auto s = stream.next()) {
             return pred(*s) ? s : none;
-        } else {
         } 
             return none;
-        }
 
     }
 };
 
@@ -64,7  64,7 @@ class TakeWhile : public Pipeable {
     P pred;
 
 public:
-    TakeWhile(P pred) : pred(pred) {}
     explicit TakeWhile(P pred) : pred(std::move(pred)) {}
 
     template <class S>
     auto pipe(S stream) const {

diff --git a/lib/lambda/type_traits.hpp b/lib/lambda/type_traits.hpp
@@ -1,8  1,8 @@
 
 #pragma once
 
-#include <type_traits>
 #include "function_traits.hpp"
 #include <type_traits>
 
 namespace lambda {
 
@@ -16,7  16,7 @@ struct has_iterator {
     template <typename U>
     static long test(U *x);
 
-    static const bool value = sizeof(test<T>(0)) == 1;
     static const bool value = sizeof(test<T>(nullptr)) == 1;
 };
 
 template <typename T>