Re: [boost] [Tick] Universal quantified concepts/traits

Subject: Re: [boost] [Tick] Universal quantified concepts/traits
From: paul Fultz (pfultz2_at_[hidden])
Date: 2014-12-16 16:53:32

Ok, I think I understand what you are aksing for. This how I would approach
the problem using Tick. It does require defining different traits to get
there(I am not sure how it could be done all in one take). First, I would
define `is_callable` that checks if a function is called with `T` and returns
`U`:

    TICK_TRAIT(is_callable)
    {
        template<class F, class T, class U>
        auto requires_(F&& f, T&& t, U&&) -> tick::valid<
            decltype(returns<U>(f(std::forward<T>(t))))
        >;
    };

Next I would write a trait that checks if the two types, `Wt` and `Wu`, are
mapped like `W<T> -> W<U>` and that the function takes `T` and returns `U`:

    template<class Wt, class Wu, class F>
    struct is_mapped
    : std::false_type
    {};

    template<template<class...> class W, class T, class U, class F>
    struct is_mapped<W<T>, W<U>, F>
    : is_callable<F, T, U>
    {};

And then I would write the `is_functor` to call the `map` function and check
that it returns a mapped type:

    TICK_TRAIT(is_functor)
    {
        template<class F, class Wt>
        auto requires_(F&& f, Wt&& wt) -> tick::valid<
            decltype(returns<is_mapped<Wt, _, F>(
                map(f, std::forward<Wt>(wt))
            ))
        >;
    };

Does that make sense? Is this what you are asking for?

Paul Fultz II 

     On Tuesday, December 16, 2014 1:37 PM, Vicente J. Botet Escriba <vicente.botet_at_[hidden]> wrote:
   
 

 Hi,

I'm trying to represent the concept of a mathematical Functor (as in 
Haskell) with Concept Lite. Here is what I want to express:

  A Functor W is a type constructor for wrappers of another type T 
providing a
  function map taking a function (T) -> U and a W<T> and returning a W<U>.

Here is how I think that could be done with Concept Lite. If I 
understand the proposal correctly we need to add the type T and the 
function parameter to the concept.

concept Functor<typename W, typename T, typename F > =
  requires {
    using WT = ApplyType<W, T>; // type constructor
    using U = ResultType<F, T>;
    using WU = ApplyType<W, U>;
    Function<F, U, T> &&
    requires (F f, WT wt) {
        WU { map(f, wt) };
    }
  };

But this is not exactly what I want to conceptualize. The wrapped type T 
and the function F should be universally quantified, that is, the 
concept concerns only the type constructor W: Functor<W>.

I have a problem introducing the universal quantification of T and F. I 
don't know how to do it without using again a template.

concept Functor<typename W> =
    template <typename T, typename F> // universal quantification on T 
and F
        requires {
          using WT = ApplyType<W, T>;
          using U = ResultType<F, T>;
          using WU = ApplyType<W, U>;
          Function<F, U, T> &&
          requires (F f, WT wt) {
              WU { map(f, wt) };
          }
        }
    };

But this is not valid code, isn't it.

Is there something wrong with this kind of concepts?
What would be the best way to conceptualize this kind of concepts with 
the Tick library ?

Best,
Vicente

_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost