Boost logo

Boost :

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

        template<class F, class T, class U>
        auto requires_(F&& f, T&& t, U&&) -> tick::valid<

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:

        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:


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 ?


Unsubscribe & other changes:


Boost list run by bdawes at, gregod at, cpdaniel at, john at