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

Subject: Re: [boost] [Tick] Universal quantified concepts/traits
From: Vicente J. Botet Escriba (vicente.botet_at_[hidden])
Date: 2014-12-17 01:20:20

Le 16/12/14 22:53, paul Fultz a écrit :
> 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?
>
>
No, this trait has two parameters F and Wt. I'm looking for a trait with 
a single parameter W, the type constructor. Maybe I'm looking for a 
thing that should not exists ;-)

> 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 ?
>
>
Vicente