ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean-up: the big anti-bang -- NullType becomes Nil

Browse source 
Since I've convinced myself during the last years that this kind
of typelist programming is ''not a workaround'' — it is even
superior to pattern matching on variadics for certain kinds
of tasks — the empty struct defined as `NullType` got into
more widespread use as a marker type in the Lumiera code base.

It seems adequate though to give it a much more evocative name
This commit is contained in:
Fischlurch 2025-06-02 17:46:40 +02:00
parent 7aa1698a95
commit f8517b7011
30 changed files with 282 additions and 281 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/lib/hetero-data.hpp
View file

@ -286,7 +286,7 @@ namespace lib {
* @internal implementation specialisation to mark the end of a chain
*/
template<>
class HeteroData<meta::NullType>
class HeteroData<meta::Nil>
{
public:
static size_t constexpr size() { return 0; }
@ -305,9 +305,9 @@ namespace lib {
*/
template<typename...DATA>
class HeteroData
: public HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::NullType>>
: public HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::Nil>>
{
using _FrontBlock = HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::NullType>>;
using _FrontBlock = HeteroData<meta::Node<StorageFrame<0, DATA...>, meta::Nil>>;
public:
using NewFrame = typename _FrontBlock::Frame;
@ -437,7 +437,7 @@ namespace std { // Specialisation to support C++ »Tuple Protocol« and structur
using type = typename lib::HeteroData<DATA...>::template Elm_t<I>;
};
template<size_t I>
struct tuple_element<I, lib::HeteroData<lib::meta::NullType> >
struct tuple_element<I, lib::HeteroData<lib::meta::Nil> >
{
static_assert ("accessing element-type of an empty HeteroData block");
};

4
src/lib/meta/function-closure.hpp
View file

@ -400,9 +400,9 @@ namespace func{
};
template<size_t i>
struct PlaceholderTuple<NullType, i>
struct PlaceholderTuple<Nil, i>
{
using List = NullType;
using List = Nil;
};

2
src/lib/meta/generator-combinations.hpp
View file

@ -77,7 +77,7 @@ namespace meta{
template
< class TYPES_1, class TYPES_2 ///< the two type collections to pick combinations from
, template<class,class,class> class _X_ ///< template with two arg types and a base type
, class BASE = NullType
, class BASE = Nil
>
struct InstantiateChainedCombinations
: InstantiateChained< typename CartesianProduct<TYPES_1,TYPES_2>::List

36
src/lib/meta/generator.hpp
View file

@ -66,18 +66,18 @@ namespace meta{
template
< class TYPES // List of Types
, template<class> class _X_ // your-template-goes-here
, class BASE = NullType // Base class at end of chain
, class BASE = Nil // Base class at end of chain
>
class InstantiateForEach;
template<template<class> class _X_, class BASE>
class InstantiateForEach<NullType, _X_, BASE>
class InstantiateForEach<Nil, _X_, BASE>
: public BASE
{
public:
typedef BASE Unit;
typedef NullType Next;
using Unit = BASE;
using Next = Nil;
};
@ -91,8 +91,8 @@ namespace meta{
public InstantiateForEach<TYPES, _X_, BASE>
{
public:
typedef _X_<TY> Unit;
typedef InstantiateForEach<TYPES,_X_> Next;
using Unit = _X_<TY>;
using Next = InstantiateForEach<TYPES,_X_>;
};
@ -115,18 +115,18 @@ namespace meta{
template
< class TYPES // List of Types
, template<class,class> class _X_ // your-template-goes-here
, class BASE = NullType // Base class at end of chain
, class BASE = Nil // Base class at end of chain
>
class InstantiateChained;
template<template<class,class> class _X_, class BASE>
class InstantiateChained<NullType, _X_, BASE>
class InstantiateChained<Nil, _X_, BASE>
: public BASE
{
public:
typedef BASE Unit;
typedef NullType Next;
using Unit = BASE;
using Next = Nil;
};
@ -141,8 +141,8 @@ namespace meta{
>
{
public:
typedef InstantiateChained<TYPES,_X_,BASE> Next;
typedef _X_<TY,Next> Unit;
using Next = InstantiateChained<TYPES,_X_,BASE>;
using Unit = _X_<TY,Next>;
};
@ -159,7 +159,7 @@ namespace meta{
template
< class TYPES // List of Types
, template<class,class,uint> class _X_ // your-template-goes-here
, class BASE = NullType // Base class at end of chain
, class BASE = Nil // Base class at end of chain
, uint i = 0 // incremented on each instantiation
>
class InstantiateWithIndex;
@ -169,12 +169,12 @@ namespace meta{
, class BASE
, uint i
>
class InstantiateWithIndex<NullType, _X_, BASE, i>
class InstantiateWithIndex<Nil, _X_, BASE, i>
: public BASE
{
public:
typedef BASE Unit;
typedef NullType Next;
using Unit = BASE;
using Next = Nil;
enum{ COUNT = i };
};
@ -192,8 +192,8 @@ namespace meta{
>
{
public:
typedef InstantiateWithIndex<TYPES,_X_,BASE,i+1> Next;
typedef _X_<TY,Next,i> Unit;
using Next = InstantiateWithIndex<TYPES,_X_,BASE,i+1>;
using Unit = _X_<TY,Next,i>;
enum{ COUNT = Next::COUNT };
};

12
src/lib/meta/tuple-helper.hpp
View file

@ -148,13 +148,13 @@ namespace meta {
};
/**
* temporary workaround: strip trailing NullType entries
* temporary workaround: strip trailing Nil-Type entries
* prior to rebinding to the `std::tuple` type.
*/
template<typename...TYPES>
struct BuildTupleType<TyOLD<TYPES...>>
{
using VariadicSeq = typename StripNullType<TyOLD<TYPES...>>::Seq;
using VariadicSeq = typename StripNil<TyOLD<TYPES...>>::Seq;
using Type = typename BuildTupleType<VariadicSeq>::Type;
};
@ -167,7 +167,7 @@ namespace meta {
};
template<>
struct BuildTupleType<NullType>
struct BuildTupleType<Nil>
{
using Type = typename BuildTupleType<TyOLD<>>::Type;
};
@ -348,7 +348,7 @@ namespace meta {
class BuildTupleAccessor< _X_, TySeq<>, TUP, i>
{
public:
using Product = _X_<NullType, TUP, TUP, i>; // Note: i == tuple size
using Product = _X_<Nil, TUP, TUP, i>; // Note: i == tuple size
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation will be obsoleted by the removal of old-style type-sequences
template
@ -359,7 +359,7 @@ namespace meta {
class BuildTupleAccessor< _X_, TyOLD<>, TUP, i>
{
public:
using Product = _X_<NullType, TUP, TUP, i>; // Note: i == tuple size
using Product = _X_<Nil, TUP, TUP, i>; // Note: i == tuple size
};
@ -390,7 +390,7 @@ namespace meta {
};
template<class TUP, uint n>
struct TupleElementDisplayer<NullType, TUP, TUP, n>
struct TupleElementDisplayer<Nil, TUP, TUP, n>
: TUP
{
TupleElementDisplayer (TUP const& tup)

72
src/lib/meta/typelist-manip.hpp
View file

@ -57,7 +57,7 @@ namespace meta {
template<class TYPES, size_t i>
struct Pick
{
typedef NullType Type;
typedef Nil Type;
};
template<class TY, class TYPES>
struct Pick<Node<TY,TYPES>, 0>
@ -99,7 +99,7 @@ namespace meta {
struct Filter;
template<template<class> class _P_>
struct Filter<NullType,_P_> { typedef NullType List; };
struct Filter<Nil,_P_> { typedef Nil List; };
template< class TY, class TYPES
, template<class> class _P_
@ -113,7 +113,7 @@ namespace meta {
/** append lists-of-types */
template<class TY1, class TY2>
struct Append { typedef Node<TY1, typename Append<TY2,NullType>::List> List; };
struct Append { typedef Node<TY1, typename Append<TY2,Nil>::List> List; };
template< class TY, class TYPES
, class TAIL
@ -121,19 +121,19 @@ namespace meta {
struct Append<Node<TY,TYPES>, TAIL> { typedef Node<TY, typename Append<TYPES, TAIL>::List> List; };
template<class TY, class TYPES>
struct Append<NullType, Node<TY,TYPES>> { typedef Node<TY,TYPES> List; };
struct Append<Nil, Node<TY,TYPES>> { typedef Node<TY,TYPES> List; };
template<class TY, class TYPES>
struct Append<Node<TY,TYPES>, NullType> { typedef Node<TY,TYPES> List; };
struct Append<Node<TY,TYPES>, Nil> { typedef Node<TY,TYPES> List; };
template<class TY1>
struct Append<TY1,NullType> { typedef Node<TY1,NullType> List; };
struct Append<TY1,Nil> { typedef Node<TY1,Nil> List; };
template<class TY2>
struct Append<NullType,TY2> { typedef Node<TY2,NullType> List; };
struct Append<Nil,TY2> { typedef Node<TY2,Nil> List; };
template<>
struct Append<NullType,NullType> { typedef NullType List; };
struct Append<Nil,Nil> { typedef Nil List; };
@ -143,11 +143,11 @@ namespace meta {
struct SplitLast;
template<>
struct SplitLast<NullType> { typedef NullType Type;
typedef NullType List; };
struct SplitLast<Nil> { typedef Nil Type;
typedef Nil List; };
template<class TY>
struct SplitLast<Node<TY,NullType>> { typedef TY Type;
typedef NullType List; };
struct SplitLast<Node<TY,Nil>> { typedef TY Type;
typedef Nil List; };
template<class TY, class TYPES>
struct SplitLast<Node<TY,TYPES>> { typedef typename SplitLast<TYPES>::Type Type;
@ -163,7 +163,7 @@ namespace meta {
* into an base typelist, starting at given index.
* @return either the combined (spliced) List, or
* the Front/Back part before or after the Overlay
* @note using a NullType as OVERLAY allows to extract
* @note using a Nil as OVERLAY allows to extract
* an arbitrary Front/Back part of the list
*/
template<class BASE, class OVERLAY, uint i=0>
@ -178,18 +178,18 @@ namespace meta {
template<class B, class BS,
class O, class OS >
struct Splice<Node<B,BS>,Node<O,OS>,0> { typedef Node<O, typename Splice<BS,OS, 0>::List> List;
typedef NullType Front;
typedef Nil Front;
typedef typename Splice<BS,OS, 0>::Back Back; };
template<class B, class BS>
struct Splice<Node<B,BS>, NullType, 0> { typedef Node<B, BS> List;
typedef NullType Front;
struct Splice<Node<B,BS>, Nil, 0> { typedef Node<B, BS> List;
typedef Nil Front;
typedef Node<B, BS> Back; };
template<class XX, uint i>
struct Splice<NullType, XX, i> { typedef NullType List;
typedef NullType Front;
typedef NullType Back; };
struct Splice<Nil, XX, i> { typedef Nil List;
typedef Nil Front;
typedef Nil Back; };
@ -206,23 +206,23 @@ namespace meta {
{
typedef Node<T,TYPES> List; ///< the complete list
typedef T Head; ///< first element
typedef Node<T,NullType> First; ///< a list containing the first element
typedef Node<T,Nil> First; ///< a list containing the first element
typedef TYPES Tail; ///< remainder of the list starting with the second elm.
typedef typename SplitLast<List>::List Prefix;///< all of the list, up to but excluding the last element
typedef typename SplitLast<List>::Type End; ///< the last element
typedef Node<End,NullType> Last; ///< a list containing the last element
typedef Node<End,Nil> Last; ///< a list containing the last element
};
template<>
struct Dissect<NullType>
struct Dissect<Nil>
{
typedef NullType List;
typedef NullType Head;
typedef NullType First;
typedef NullType Tail;
typedef NullType Prefix;
typedef NullType End;
typedef NullType Last;
typedef Nil List;
typedef Nil Head;
typedef Nil First;
typedef Nil Tail;
typedef Nil Prefix;
typedef Nil End;
typedef Nil Last;
};
@ -233,13 +233,13 @@ namespace meta {
* yielding a list-of lists-of-types
*/
template<class T, class TY>
struct PrefixAll { typedef Node< typename Append<T,TY>::List, NullType> List; };
struct PrefixAll { typedef Node< typename Append<T,TY>::List, Nil> List; };
template<class T>
struct PrefixAll<T, NullType> { typedef NullType List; };
struct PrefixAll<T, Nil> { typedef Nil List; };
template<class T>
struct PrefixAll<T, NodeNull> { typedef Node< typename Append<T,NodeNull>::List, NullType> List; };
struct PrefixAll<T, NilNode> { typedef Node< typename Append<T, NilNode>::List, Nil> List; };
template< class T
, class TY, class TYPES
@ -261,7 +261,7 @@ namespace meta {
struct Distribute { typedef typename PrefixAll<TY1,TY2>::List List; };
template<class TY>
struct Distribute<NullType,TY> { typedef NullType List; };
struct Distribute<Nil,TY> { typedef Nil List; };
template< class TY, class TYPES
, class TAIL
@ -287,10 +287,10 @@ namespace meta {
template< class X
, template<class> class _ENUM_>
struct Combine { typedef typename Distribute< typename _ENUM_<X>::List
, Node<NullType,NullType>
, Node<Nil,Nil>
>::List List; };
template< template<class> class _ENUM_>
struct Combine<NullType, _ENUM_ > { typedef NodeNull List; };
struct Combine<Nil, _ENUM_ > { typedef NilNode List; };
template< class TY, class TYPES
, template<class> class _ENUM_>
@ -304,7 +304,7 @@ namespace meta {
template<class F>
struct FlagOnOff
{
typedef Node<F, Node<NullType,NullType>> List;
typedef Node<F, Node<Nil,Nil>> List;
};

12
src/lib/meta/typelist-util.hpp
View file

@ -51,7 +51,7 @@ namespace meta {
template<class TYPES>
struct count;
template<>
struct count<NullType>
struct count<Nil>
{
enum{ value = 0 };
};
@ -68,7 +68,7 @@ namespace meta {
template<class TYPES>
struct maxSize;
template<>
struct maxSize<NullType>
struct maxSize<Nil>
{
static constexpr int value = 0;
};
@ -87,7 +87,7 @@ namespace meta {
template<class TYPES>
struct maxAlign;
template<>
struct maxAlign<NullType>
struct maxAlign<Nil>
{
static constexpr int value = 0;
};
@ -138,15 +138,15 @@ namespace meta {
struct ConstAll;
template<>
struct ConstAll<NullType>
struct ConstAll<Nil>
{
typedef NullType List;
using List = Nil;
};
template<typename TY, typename TYPES>
struct ConstAll<Node<TY,TYPES>>
{
typedef Node<const TY, typename ConstAll<TYPES>::List> List;
using List = Node<const TY, typename ConstAll<TYPES>::List>;
};

88
src/lib/meta/typelist.hpp
View file

@ -10,16 +10,16 @@
  option) any later version. See the file COPYING for further details.
====================================================================
This code is heavily inspired by
This code is heavily inspired by
The Loki Library (loki-lib/trunk/include/loki/Sequence.h)
Copyright (c) 2001 by Andrei Alexandrescu
Copyright (c) 2005 by Peter Kümmel
This Loki code accompanies the book:
Alexandrescu, Andrei. "Modern C++ Design: Generic Programming
and Design Patterns Applied".
and Design Patterns Applied".
Copyright (c) 2001. Addison-Wesley. ISBN 0201704315
Loki Copyright Notice:
Loki Copyright Notice:
Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
@ -32,14 +32,16 @@ This code is heavily inspired by
/** @file typelist.hpp
** A template metaprogramming technique for manipulating collections of types.
** Effectively this is a tailored and simplified version of what can be found in the Loki library.
** We use it in other generic library-style code to generate repetitive code. If you tend to find
** template metaprogramming (or functional programming in general) offending, please ignore the
** technical details and just consider the benefit of such an simplification for the client code.
**
** Interface for using this facility is the template Types(.....) for up to 20 Type parameters.
** We use it in other generic library-style code to generate repetitive code.
** @remark If you tend to find the use of template metaprogramming detrimental
** (or functional programming and generally any kind of abstraction)
** please kindly ignore the technical details and just consider the
** benefit of simplification for the client code.
**
** Interface for using this facility is the template `Types<TS...>`.
** To start typelist processing, other templates typically pick up the Types<...>::List type.
** This allows for LISP-style list processing, with a pattern match on either Node<TY,TYPES>
** or NullType to terminate recursion. In C++ template metaprogramming, "pattern match"
** This allows for LISP-style list processing, with a pattern match on either `Node<TY,TYPES>`
** or the type `Nil` to terminate recursion. In C++ template metaprogramming, "pattern match"
** is done by partial template specialisations (the compiler will pick up and thus
** match the template parameters). A typedef acts like a declaration in normal
** programming. Because such a "declaration" can't be changed after the fact,
@ -74,44 +76,44 @@ This code is heavily inspired by
namespace lib {
namespace meta {
struct NullType
{
typedef NullType List;
struct Nil
{
using List = Nil;
};
template<class H, class T>
template<class H, class T>
struct Node
{
typedef Node List;
typedef H Head;
typedef T Tail;
using List = Node;
using Head = H;
using Tail = T;
};
typedef Node<NullType,NullType> NodeNull;
using NilNode = Node<Nil,Nil>;
template
< class T01=NullType
, class T02=NullType
, class T03=NullType
, class T04=NullType
, class T05=NullType
, class T06=NullType
, class T07=NullType
, class T08=NullType
, class T09=NullType
, class T10=NullType
, class T11=NullType
, class T12=NullType
, class T13=NullType
, class T14=NullType
, class T15=NullType
, class T16=NullType
, class T17=NullType
, class T18=NullType
, class T19=NullType
, class T20=NullType
< class T01=Nil
, class T02=Nil
, class T03=Nil
, class T04=Nil
, class T05=Nil
, class T06=Nil
, class T07=Nil
, class T08=Nil
, class T09=Nil
, class T10=Nil
, class T11=Nil
, class T12=Nil
, class T13=Nil
, class T14=Nil
, class T15=Nil
, class T16=Nil
, class T17=Nil
, class T18=Nil
, class T19=Nil
, class T20=Nil
>
class TyOLD
{
@ -125,10 +127,10 @@ namespace meta {
using Seq = TyOLD;
};
template<>
template<>
struct TyOLD<>
{
using List = NullType;
using List = Nil;
using Seq = TyOLD<>;
};
@ -139,9 +141,9 @@ namespace meta {
* alternative definition of "type sequence",
* already using variadic template parameters.
* @remarks the problem with our existing type sequence type
* is that it fills the end of each sequence with NullType,
* is that it fills the end of each sequence with Nil,
* which was the only way to get a flexible type sequence
* prior to C++11. Unfortunately these trailing NullType
* prior to C++11. Unfortunately these trailing Nil
* entries do not play well with other variadic defs.
* @deprecated when we switch our primary type sequence type
* to variadic parameters, this type will be obsoleted. ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic

29
src/lib/meta/typeseq-util.hpp
View file

@ -166,16 +166,16 @@ namespace meta {
>::Seq;
};
template<>
struct TySeq<NullType>
struct TySeq<Nil>
{
using List = NullType;
using List = Nil;
using Seq = TySeq<>;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
/**
* temporary workaround: strip trailing NullType entries from a
* temporary workaround: strip trailing Nil entries from a
* type sequence, to make it compatible with new-style variadic
* template definitions.
* @note the result type is a TySec, to keep it apart from our
@ -183,24 +183,24 @@ namespace meta {
* @deprecated necessary for the transition to variadic sequences ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic
*/
template<typename SEQ>
struct StripNullType;
struct StripNil;
template<typename T, typename...TYPES>
struct StripNullType<TyOLD<T,TYPES...>>
struct StripNil<TyOLD<T,TYPES...>>
{
using TailSeq = typename StripNullType<TyOLD<TYPES...>>::Seq;
using TailSeq = typename StripNil<TyOLD<TYPES...>>::Seq;
using Seq = typename Prepend<T, TailSeq>::Seq;
};
template<typename...TYPES>
struct StripNullType<TyOLD<NullType, TYPES...>>
struct StripNil<TyOLD<Nil, TYPES...>>
{
using Seq = TySeq<>; // NOTE: this causes the result to be a TySeq
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation is a catch-all and becomes obsolete
template<typename...TYPES>
struct StripNullType<TySeq<TYPES...>>
struct StripNil<TySeq<TYPES...>>
{
using Seq = TySeq<TYPES...>;
};
@ -237,20 +237,20 @@ namespace meta {
template<>
struct Split<TySeq<>>
{
using List = NullType;
using List = Nil;
using Head = NullType;
using Head = Nil;
using First = TySeq<>;
using Tail = TySeq<>;
// for finding the end we need the help of typelist-util.hpp
using PrefixList = NullType;
using TailList = NullType;
using PrefixList = Nil;
using TailList = Nil;
using Prefix = TySeq<>;
using Last = TySeq<>;
using End = NullType;
using End = Nil;
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation will be obsoleted by the removal of old-style type-sequences
template< typename T01
@ -309,7 +309,7 @@ namespace meta {
/**
* Helper: generate a type sequence left shifted
* by i steps, filling in NullType at the end
* by i steps, filling in Nil at the end
*/
template<class TYPES, uint i=1>
class Shifted
@ -326,6 +326,7 @@ namespace meta {
typedef TYPES Type;
typedef typename Split<Type>::Head Head;
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : reimplement for variadic type-sequences

2
src/lib/meta/variadic-helper.hpp
View file

@ -143,7 +143,7 @@ namespace meta {
template<typename...TYPES>
struct BuildIdxIter<TyOLD<TYPES...>>
{
///////////////////////TICKET #987 : since Types<T...> is not variadic, need to strip NullType here (instead of just using sizeof...(TYPES)
///////////////////////TICKET #987 : since Types<T...> is not variadic, need to strip Nil-Type here (instead of just using sizeof...(TYPES)
enum {SIZ = lib::meta::count<typename TyOLD<TYPES...>::List>::value };
using Builder = BuildIndexSeq<SIZ>;

4
src/lib/meta/variadic-rebind.hpp
View file

@ -103,7 +103,7 @@ namespace meta {
* A secondary helper template variant is provided for rebinding
* while prepending or appending a single type parameter.
* @note does not work with empty sequences; also the penultimate
* of a one-element sequence is mapped to NullType
* of a one-element sequence is mapped to the `Nil`-type
*/
template<template<class...> class L, typename...XS>
struct _Vari;
@ -129,7 +129,7 @@ namespace meta {
struct _Vari<L, X>
{
using Ultima = X;
using Penult = NullType; ///< marker for undefined
using Penult = Nil; ///< marker for undefined
using Remain = L<X>;
using Revers = L<X>;
using Prefix = L<>;

20
src/lib/parse.hpp
View file

@ -162,8 +162,8 @@ namespace util {
using std::optional;
using lib::meta::_Fun;
using lib::meta::has_Sig;
using lib::meta::NullType;
using lib::meta::_Vari;
using lib::meta::Nil;
using std::decay_t;
using std::tuple;
using std::array;
@ -221,14 +221,14 @@ namespace util {
/** »Null-Connex« which always successfully accepts the empty sequence */
inline auto
buildConnex(NullType)
buildConnex(Nil)
{
return Connex{[](StrView) -> Eval<NullType>
return Connex{[](StrView) -> Eval<Nil>
{
return {NullType{}};
return {Nil()};
}};
}
using NulP = decltype(buildConnex (NullType()));
using NulP = decltype(buildConnex (Nil()));
/**
@ -729,7 +729,7 @@ namespace util {
};
/* === Deduction guide : how to construct a Parser === */
Parser(NullType) -> Parser<NulP>;
Parser(Nil) -> Parser<NulP>;
Parser(regex &&) -> Parser<Term>;
Parser(regex const&) -> Parser<Term>;
Parser(string const&) -> Parser<Term>;
@ -787,7 +787,7 @@ namespace util {
using Result = typename PAR::Result;
Syntax()
: parse_{NullType()}
: parse_{Nil()}
{ }
explicit
@ -948,21 +948,21 @@ namespace util {
inline auto
accept_repeated (uint min, uint max, SPEC&& clauseDef)
{
return accept_repeated (min, max, NullType{}, forward<SPEC>(clauseDef));
return accept_repeated (min, max, Nil{}, forward<SPEC>(clauseDef));
}
template<typename SPEC>
inline auto
accept_repeated (uint cnt, SPEC&& clauseDef)
{
return accept_repeated (cnt, NullType{}, forward<SPEC>(clauseDef));
return accept_repeated (cnt, Nil{}, forward<SPEC>(clauseDef));
}
template<typename SPEC>
inline auto
accept_repeated (SPEC&& clauseDef)
{
return accept_repeated (NullType{}, forward<SPEC>(clauseDef));
return accept_repeated (Nil{}, forward<SPEC>(clauseDef));
}
/**

6
src/lib/time/formats.hpp
View file

@ -168,7 +168,7 @@ namespace time {
using lib::meta::TyOLD;
using lib::meta::Node;
using lib::meta::NullType;
using lib::meta::Nil;
/**
* Descriptor to denote support for a specific (timecode) format.
@ -204,9 +204,9 @@ namespace time {
flags_.set (typeID<F>());
return define(FS());
}
Supported define(NullType) { return *this;} ///< @internal recursion end
Supported define(Nil) { return *this;} ///< @internal recursion end
Supported() { } ///< @note use #formats to set up a new descriptor
Supported() { } ///< @note use #formats to set up a new descriptor
public:

4
src/lib/variant.hpp
View file

@ -98,9 +98,9 @@ namespace lib {
namespace variant { // implementation metaprogramming helpers
using std::remove_reference;
using meta::NullType;
using meta::TyOLD;
using meta::Node;
using meta::Nil;
template<typename X, typename TYPES>
@ -137,7 +137,7 @@ namespace lib {
{ };
template<typename X>
struct CanBuildFrom<X, NullType>
struct CanBuildFrom<X, Nil>
: std::false_type
{ };

2
src/lib/visitor.hpp
View file

@ -138,7 +138,7 @@ namespace visitor {
< class TOOLImpl,
class BASE
>
class Applicable<TOOLImpl, typelist::NullType, BASE>
class Applicable<TOOLImpl, typelist::Nil, BASE>
: public BASE
{ }
;

1
src/steam/control/command-def.hpp
View file

@ -77,7 +77,6 @@ namespace control {
using lib::Symbol;
using lib::meta::_Fun;
using lib::meta::NullType;
using lib::meta::TyOLD;
using lib::meta::Tuple;

4
src/steam/control/command-op-closure.hpp
View file

@ -52,8 +52,8 @@ namespace control {
using lib::meta::Tuple;
using lib::meta::BuildTupleAccessor;
using lib::meta::func::TupleApplicator;
using lib::meta::NullType;
using lib::meta::buildTuple;
using lib::meta::Nil;
using lib::TypedAllocationManager;
using std::function;
@ -94,7 +94,7 @@ namespace control {
};
template<class TUP, uint n>
class ParamAccessor<NullType, TUP, TUP, n> ///< used for recursion end of implementation functions
class ParamAccessor<Nil, TUP, TUP, n> ///< used for recursion end of implementation functions
: public TUP
{
public:

4
src/steam/engine/feed-manifold.hpp
View file

@ -100,9 +100,9 @@ namespace engine {
using lib::meta::is_Structured;
using lib::meta::forEachIDX;
using lib::meta::ElmTypes;
using lib::meta::NullType;
using lib::meta::Tagged;
using lib::meta::TySeq;
using lib::meta::Nil;
using std::is_pointer;
using std::is_reference;
using std::is_convertible;
@ -372,7 +372,7 @@ namespace engine {
using enable_if_hasParam = typename lib::meta::enable_if_c<_ProcFun<F>::hasParam()>::type;
template<class X>
using NotProvided = Tagged<NullType, X>;
using NotProvided = Tagged<Nil, X>;
template<bool yes, class B>
using Provide_if = conditional_t<yes, B, NotProvided<B>>;

8
src/steam/engine/proc-node.cpp
View file

@ -65,11 +65,11 @@ namespace engine {
/* ===== Parse nested spec ===== */
using lib::meta::Nil;
using util::parse::accept;
using util::parse::accept_bracket;
using util::parse::accept_repeated;
using util::parse::expectResult;
using lib::meta::NullType;
using std::regex_match;
using std::regex;
@ -91,13 +91,13 @@ namespace engine {
regex CLOSING{esc+CLO};
regex NON_PAREN{R"_([^\\)_"+esc+OPE+esc+CLO+"]+"};
static auto paren = expectResult<NullType>();
static auto paren = expectResult<Nil>();
auto parenContent = accept_repeated(accept(NON_PAREN)
.alt(ESCAPE)
.alt(quote)
.alt(paren));
paren = accept_bracket(OPENING,CLOSING, parenContent).bind([](auto){ return NullType{}; });
paren = accept_bracket(OPENING,CLOSING, parenContent).bind([](auto){ return Nil{}; });
return paren;
}
@ -403,7 +403,7 @@ namespace engine {
namespace {// create a »backdoor access« into actual weaving-pattern instances
using _DummyProc = void(&)(NullType*);
using _DummyProc = void(&)(Nil*);
using _DummyProto = FeedPrototype<_DummyProc>;
using _DummyMediaWeaving = MediaWeavingPattern<_DummyProto>;
using _RecastMediaWeaving = _TurnoutDiagnostic<_DummyMediaWeaving>;

2
src/steam/mobject/session/session-service-defaults.hpp
View file

@ -38,7 +38,7 @@ namespace session {
// using lib::meta::InstantiateChained;
// using lib::meta::InheritFrom;
// using lib::meta::NullType;
// using lib::meta::Nil;
class SessionServiceDefaults

2
src/steam/mobject/session/session-service-fetch.hpp
View file

@ -41,7 +41,7 @@ namespace session {
// using lib::meta::InstantiateChained;
// using lib::meta::InheritFrom;
// using lib::meta::NullType;
// using lib::meta::Nil;
/**
* Implementation-level service for resolving an Placement-ID.

2
tests/library/hetero-data-test.cpp
View file

@ -170,7 +170,7 @@ namespace test{
CHECK (x2 == "Φ"_expect);
// auto& [z0,z1,z2,z3] = chain2; // Error: 4 names provided for structured binding, while HeteroData... decomposes into 3 elements
// auto& [z0,z1,z2] = b1; // Error: HeteroData<Node<StorageFrame<0, uint>, NullType> >' decomposes into 1 element
// auto& [z0,z1,z2] = b1; // Error: HeteroData<Node<StorageFrame<0, uint>, Nil> >' decomposes into 1 element
}

4
tests/library/meta/generator-combinations-test.cpp
View file

@ -68,7 +68,7 @@ namespace test {
};
template<>
struct TestCase<void,void,NullType>
struct TestCase<void,void,Nil>
{
static string
visitAll()
@ -76,7 +76,7 @@ namespace test {
return "-|";
}
};
typedef TestCase<void,void,NullType> IterationEnd;
typedef TestCase<void,void,Nil> IterationEnd;
} // (End) test data

2
tests/library/meta/meta-utils-test.cpp
View file

@ -186,7 +186,7 @@ namespace test {
CHECK ((not is_Structured<int const && >()));
CHECK ((not is_Structured<double >()));
CHECK ((not is_Structured<string >()));
CHECK ((not is_Structured<Node<short,NullType> >()));
CHECK ((not is_Structured<Node<short,Nil> >()));
// the following indeed support C++ tuple protocol
CHECK (( is_Structured<tuple<int> >()));

6
tests/library/meta/tuple-helper-test.cpp
View file

@ -125,8 +125,8 @@ namespace test {
Prepend prep (22, 11,33,Num<5>());
DUMPVAL (prep);
typedef Tuple<TyOLD<> > NulT; // plain-flat empty Tuple
typedef Tuple<NullType> NulL; // list-style empty Tuple
using NulT = Tuple<TyOLD<> >; // plain-flat empty Tuple
using NulL = Tuple<Nil>; // list-style empty Tuple
NulT nulT; // and these, too, can be instantiated
NulL nulL;
@ -139,7 +139,7 @@ namespace test {
CHECK (is_Tuple<T_L1>());
CHECK (is_Tuple<Prepend>());
CHECK (is_Tuple<NulT>());
CHECK (!is_Tuple<Seq1>());
CHECK (not is_Tuple<Seq1>());
cout << tup1 <<endl // these automatically use our generic string conversion
<< prep <<endl

8
tests/library/meta/typelist-diagnostics.hpp
View file

@ -80,8 +80,8 @@ namespace meta {
/** helper for generating test lists */
template<class X> struct CountDown { typedef NullType List; };
template<> struct CountDown<Num<0>> { typedef Node<Num<0>, NullType> List; };
template<class X> struct CountDown { typedef Nil List; };
template<> struct CountDown<Num<0>> { typedef Node<Num<0>, Nil> List; };
template<int I> struct CountDown<Num<I>> { typedef Node<Num<I>, typename CountDown<Num<I-1>>::List> List; };
@ -101,7 +101,7 @@ namespace meta {
/** debugging template,
* printing the "number" used for instantiation on ctor call
*/
template<class T=NullType, class BASE=NullP>
template<class T=Nil, class BASE=NullP>
struct Printer
: BASE
{
@ -109,7 +109,7 @@ namespace meta {
};
template<class BASE>
struct Printer<NullType, BASE>
struct Printer<Nil, BASE>
: BASE
{
static string print () { return _Fmt("-<%u>%s") % "·" % BASE::print(); }

145
tests/library/meta/typelist-manip-test.cpp
View file

@ -75,7 +75,7 @@ namespace test {
* @test check utilities for manipulating lists-of-types.
* - build an list of constant-wrapper-types and
* print them for debugging purpose.
* - append lists, single elements and NullType
* - append lists, single elements and Nil-Type
* in various combinations
* - manipulations like splice, get end, dissect
* - filtering out some types from a typelist by
@ -124,48 +124,48 @@ namespace test {
Pick<List2,1>::Type e1;
Pick<List2,2>::Type e2;
typedef Pick<List2,3>::Type E3;
typedef Pick<NullType,23>::Type Nil;
typedef Pick<void*,456>::Type Irrelevant;
using E3 = Pick<List2,3>::Type;
using NilE = Pick<Nil, 23>::Type;
using Irrelevant = Pick<void*,456>::Type;
CHECK (5 == e0);
CHECK (6 == e1);
CHECK (7 == e2);
CHECK ((is_same<NullType, E3> ::value));
CHECK ((is_same<NullType, Nil> ::value));
CHECK ((is_same<NullType, Irrelevant>::value));
CHECK ((is_same<Nil, E3> ::value));
CHECK ((is_same<Nil, NilE> ::value));
CHECK ((is_same<Nil, Irrelevant>::value));
}
void
check_append ()
{
typedef Append<NullType, NullType> Append1;
using Append1 = Append<Nil, Nil>;
DISPLAY (Append1);
typedef Append<Num<11>,Num<22>> Append2;
using Append2 = Append<Num<11>,Num<22>>;
DISPLAY (Append2);
typedef Append<Num<111>,NullType> Append3;
using Append3 = Append<Num<111>,Nil>;
DISPLAY (Append3);
typedef Append<NullType,Num<222>> Append4;
using Append4 = Append<Nil,Num<222>>;
DISPLAY (Append4);
typedef Append<List1,NullType> Append5;
using Append5 = Append<List1,Nil>;
DISPLAY (Append5);
typedef Append<NullType,List2> Append6;
using Append6 = Append<Nil,List2>;
DISPLAY (Append6);
typedef Append<Num<111>,List2> Append7;
using Append7 = Append<Num<111>,List2>;
DISPLAY (Append7);
typedef Append<List1,Num<222>> Append8;
using Append8 = Append<List1,Num<222>>;
DISPLAY (Append8);
typedef Append<List1,List2> Append9;
using Append9 = Append<List1,List2>;
DISPLAY (Append9);
}
@ -173,66 +173,66 @@ namespace test {
void
check_splice ()
{
typedef TyOLD<Num<9>,Num<8>>::List OLi;
using OLi = TyOLD<Num<9>,Num<8>>::List;
// will "paste" the list OLi "on top" of another Typelist...
typedef Splice<NullType, NullType> Overl01;
using Overl01 = Splice<Nil, Nil>;
DISPLAY (Overl01);
typedef Splice<NullType, OLi> Overl02;
using Overl02 = Splice<Nil, OLi>;
DISPLAY (Overl02);
typedef Splice<NullType, OLi, 5> Overl03;
using Overl03 = Splice<Nil, OLi, 5>;
DISPLAY (Overl03);
typedef Splice<List1, OLi> Overl04;
using Overl04 = Splice<List1, OLi>;
DISPLAY (Overl04);
typedef Splice<List1, OLi, 1> Overl05;
using Overl05 = Splice<List1, OLi, 1>;
DISPLAY (Overl05);
typedef Splice<List1, OLi, 2> Overl06;
using Overl06 = Splice<List1, OLi, 2>;
DISPLAY (Overl06);
typedef Splice<List1, OLi, 3> Overl07;
using Overl07 = Splice<List1, OLi, 3>;
DISPLAY (Overl07);
typedef Splice<List1, OLi, 5> Overl08;
using Overl08 = Splice<List1, OLi, 5>;
DISPLAY (Overl08);
typedef Splice<List1, List1> Overl09;
using Overl09 = Splice<List1, List1>;
DISPLAY (Overl09);
typedef Splice<List1, List1, 1> Overl10;
using Overl10 = Splice<List1, List1, 1>;
DISPLAY (Overl10);
typedef Splice<List1, NullType> Overl11;
using Overl11 = Splice<List1, Nil>;
DISPLAY (Overl11);
typedef Splice<List1, NullType, 1> Overl12;
using Overl12 = Splice<List1, Nil, 1>;
DISPLAY (Overl12);
typedef Splice<List1, NullType, 5> Overl13;
using Overl13 = Splice<List1, Nil, 5>;
DISPLAY (Overl13);
typedef TyOLD<Num<99>>::List OLi2;
typedef Splice<List1, OLi2, 0>::Front Front1;
typedef Splice<List1, OLi2, 1>::Front Front2;
typedef Splice<List1, OLi2, 5>::Front Front3;
using OLi2 = TyOLD<Num<99>>::List;
using Front1 = Splice<List1, OLi2, 0>::Front;
using Front2 = Splice<List1, OLi2, 1>::Front;
using Front3 = Splice<List1, OLi2, 5>::Front;
DISPLAY (Front1);
DISPLAY (Front2);
DISPLAY (Front3);
typedef Splice<List1, OLi2, 0>::Back Back1;
typedef Splice<List1, OLi2, 1>::Back Back2;
typedef Splice<List1, OLi2, 5>::Back Back3;
using Back1 = Splice<List1, OLi2, 0>::Back;
using Back2 = Splice<List1, OLi2, 1>::Back;
using Back3 = Splice<List1, OLi2, 5>::Back;
DISPLAY (Back1);
DISPLAY (Back2);
DISPLAY (Back3);
// Note: with a Null-Overlay, this can be used to extract arbitrary sublists:
typedef Splice<List1, NullType, 1>::Front Front4;
typedef Splice<List1, NullType, 1>::Back Back4;
using Front4 = Splice<List1, Nil, 1>::Front;
using Back4 = Splice<List1, Nil, 1>::Back;
DISPLAY (Front4);
DISPLAY (Back4);
}
@ -241,25 +241,25 @@ namespace test {
void
check_s_last()
{
typedef SplitLast<List1>::Type Elm;
typedef SplitLast<List1>::List Prefix;
using Elm = SplitLast<List1>::Type;
using Prefix = SplitLast<List1>::List;
typedef TyOLD<Elm>::List ElmL;
using ElmL = TyOLD<Elm>::List;
DISPLAY (Prefix);
DISPLAY (ElmL);
typedef SplitLast<ElmL>::Type Elm1;
typedef SplitLast<ElmL>::List NPrefix;
using Elm1 = SplitLast<ElmL>::Type;
using NPrefix = SplitLast<ElmL>::List;
DISPLAY (NPrefix);
DISPLAY (TyOLD<Elm1>);
typedef SplitLast<NullType>::Type Nil;
typedef SplitLast<NullType>::List NList;
using NilSplit = SplitLast<Nil>::Type;
using NList = SplitLast<Nil>::List;
DISPLAY (NList);
DISPLAY (TyOLD<Nil>);
DISPLAY (TyOLD<NilSplit>);
}
@ -269,16 +269,16 @@ namespace test {
typedef Append<List1,List2>::List LL;
DISPLAY (LL);
typedef Dissect<LL>::List List; DISPLAY(List);
typedef Dissect<LL>::First First; DISPLAY(First);
typedef Dissect<LL>::Tail Tail; DISPLAY(Tail);
typedef Dissect<LL>::Prefix Prefix; DISPLAY(Prefix);
typedef Dissect<LL>::Last Last; DISPLAY(Last);
using List = Dissect<LL>::List; DISPLAY(List);
using First = Dissect<LL>::First; DISPLAY(First);
using Tail = Dissect<LL>::Tail; DISPLAY(Tail);
using Prefix = Dissect<LL>::Prefix; DISPLAY(Prefix);
using Last = Dissect<LL>::Last; DISPLAY(Last);
typedef Dissect<LL>::Head Head;
typedef Dissect<LL>::End End;
using Head = Dissect<LL>::Head;
using End = Dissect<LL>::End;
typedef TyOLD<Head,End> HeadEnd; DISPLAY(HeadEnd);
using HeadEnd = TyOLD<Head,End>; DISPLAY(HeadEnd);
}
@ -290,7 +290,7 @@ namespace test {
void
check_apply ()
{
typedef Apply<List1, AddConst2> Added2;
using Added2 = Apply<List1, AddConst2>;
DISPLAY (Added2);
}
@ -301,7 +301,7 @@ namespace test {
void
check_filter ()
{
typedef Filter<Append<List1,List2>::List, IsEven > FilterEven;
using FilterEven = Filter<Append<List1,List2>::List, IsEven >;
DISPLAY (FilterEven);
}
@ -309,23 +309,23 @@ namespace test {
void
check_prefix ()
{
typedef PrefixAll<Num<11>,Num<22>> Prefix1;
using Prefix1 = PrefixAll<Num<11>,Num<22>>;
DISPLAY (Prefix1);
typedef PrefixAll<Num<101>,List1> Prefix2;
using Prefix2 = PrefixAll<Num<101>,List1>;
DISPLAY (Prefix2);
typedef PrefixAll<NullType,List1> Prefix3;
using Prefix3 = PrefixAll<Nil,List1>;
DISPLAY (Prefix3);
typedef TyOLD<List1::List,Num<0>,List2::List>::List List_of_Lists;
typedef PrefixAll<Num<111>,List_of_Lists> Prefix4;
using List_of_Lists = TyOLD<List1::List,Num<0>,List2::List>::List;
using Prefix4 = PrefixAll<Num<111>, List_of_Lists>;
DISPLAY (Prefix4);
typedef PrefixAll<List1,List2> Prefix5;
using Prefix5 = PrefixAll<List1,List2>;
DISPLAY (Prefix5);
typedef PrefixAll<List1,List_of_Lists> Prefix6;
using Prefix6 = PrefixAll<List1,List_of_Lists>;
DISPLAY (Prefix6);
}
@ -333,17 +333,17 @@ namespace test {
void
check_distribute()
{
typedef Distribute<Num<11>, List1> Dist1;
using Dist1 = Distribute<Num<11>, List1>;
DISPLAY (Dist1);
typedef TyOLD<Num<11>,Num<22>,Num<33>>::List Prefixes;
typedef Distribute<Prefixes, Num<0>> Dist2;
using Prefixes = TyOLD<Num<11>,Num<22>,Num<33>>::List;
using Dist2 = Distribute<Prefixes, Num<0>>;
DISPLAY (Dist2);
typedef Distribute<Prefixes, List1> Dist3;
using Dist3 = Distribute<Prefixes, List1>;
DISPLAY (Dist3);
typedef Distribute<Prefixes, TyOLD<List1::List,List2::List>::List> Dist4;
using Dist4 = Distribute<Prefixes, TyOLD<List1::List,List2::List>::List>;
DISPLAY (Dist4);
}
@ -351,17 +351,16 @@ namespace test {
void
check_combine()
{
typedef CountDown<Num<11>> Down;
using Down = CountDown<Num<11>>;
DISPLAY (Down);
typedef Combine<List1::List, CountDown> Combi;
using Combi = Combine<List1::List, CountDown>;
DISPLAY (Combi);
typedef CombineFlags<List1::List> OnOff;
using OnOff = CombineFlags<List1::List>;
DISPLAY (OnOff);
}
};

68
tests/library/meta/typeseq-manip-test.cpp
View file

@ -96,15 +96,15 @@ namespace test {
void
check_buildSeq ()
{
typedef Append<Types1::List, Types2::List>::List LL;
using LL = Append<Types1::List, Types2::List>::List;
DISPLAY (LL);
typedef TyOLD<LL>::Seq Seq;
typedef Seq::List SeqList;
using Seq = TyOLD<LL>::Seq;
using SeqList = Seq::List;
DISPLAY (Seq);
DISPLAY (SeqList);
typedef TyOLD<NodeNull>::Seq NulS;
using NulS = TyOLD<NilNode>::Seq;
DISPLAY (NulS);
}
@ -112,16 +112,16 @@ namespace test {
void
check_prepend ()
{
typedef Prepend<Num<5>, Types1> Prepend1;
using Prepend1 = Prepend<Num<5>, Types1 >;
DISPLAY(Prepend1);
typedef Prepend<NullType, Types1> Prepend2;
using Prepend2 = Prepend<Nil, Types1 >;
DISPLAY(Prepend2);
typedef Prepend<Num<5>, TyOLD<> > Prepend3;
using Prepend3 = Prepend<Num<5>, TyOLD<>>;
DISPLAY(Prepend3);
typedef Prepend<NullType, TyOLD<> > Prepend4;
using Prepend4 = Prepend<Nil, TyOLD<>>;
DISPLAY(Prepend4);
}
@ -129,44 +129,44 @@ namespace test {
void
check_shift ()
{
typedef Append<Types2::List, Types1::List>::List LL;
typedef TyOLD<LL>::Seq Seq;
using LL = Append<Types2::List, Types1::List>::List;
using Seq = TyOLD<LL>::Seq;
typedef Shifted<Seq,0>::Type Seq_0; DISPLAY (Seq_0);
typedef Shifted<Seq,1>::Type Seq_1; DISPLAY (Seq_1);
typedef Shifted<Seq,2>::Type Seq_2; DISPLAY (Seq_2);
typedef Shifted<Seq,3>::Type Seq_3; DISPLAY (Seq_3);
typedef Shifted<Seq,4>::Type Seq_4; DISPLAY (Seq_4);
typedef Shifted<Seq,5>::Type Seq_5; DISPLAY (Seq_5);
typedef Shifted<Seq,6>::Type Seq_6; DISPLAY (Seq_6);
using Seq_0 = Shifted<Seq,0>::Type; DISPLAY (Seq_0);
using Seq_1 = Shifted<Seq,1>::Type; DISPLAY (Seq_1);
using Seq_2 = Shifted<Seq,2>::Type; DISPLAY (Seq_2);
using Seq_3 = Shifted<Seq,3>::Type; DISPLAY (Seq_3);
using Seq_4 = Shifted<Seq,4>::Type; DISPLAY (Seq_4);
using Seq_5 = Shifted<Seq,5>::Type; DISPLAY (Seq_5);
using Seq_6 = Shifted<Seq,6>::Type; DISPLAY (Seq_6);
typedef TyOLD<Shifted<Seq,0>::Head> Head_0; DISPLAY (Head_0);
typedef TyOLD<Shifted<Seq,1>::Head> Head_1; DISPLAY (Head_1);
typedef TyOLD<Shifted<Seq,2>::Head> Head_2; DISPLAY (Head_2);
typedef TyOLD<Shifted<Seq,3>::Head> Head_3; DISPLAY (Head_3);
typedef TyOLD<Shifted<Seq,4>::Head> Head_4; DISPLAY (Head_4);
typedef TyOLD<Shifted<Seq,5>::Head> Head_5; DISPLAY (Head_5);
typedef TyOLD<Shifted<Seq,6>::Head> Head_6; DISPLAY (Head_6);
using Head_0 = TyOLD<Shifted<Seq,0>::Head>; DISPLAY (Head_0);
using Head_1 = TyOLD<Shifted<Seq,1>::Head>; DISPLAY (Head_1);
using Head_2 = TyOLD<Shifted<Seq,2>::Head>; DISPLAY (Head_2);
using Head_3 = TyOLD<Shifted<Seq,3>::Head>; DISPLAY (Head_3);
using Head_4 = TyOLD<Shifted<Seq,4>::Head>; DISPLAY (Head_4);
using Head_5 = TyOLD<Shifted<Seq,5>::Head>; DISPLAY (Head_5);
using Head_6 = TyOLD<Shifted<Seq,6>::Head>; DISPLAY (Head_6);
}
void
check_split ()
{
typedef Append<Types1::List, Types2::List>::List LL;
typedef TyOLD<LL>::Seq Seq;
using LL = Append<Types1::List, Types2::List>::List;
using Seq = TyOLD<LL>::Seq;
DISPLAY (Seq);
typedef Split<Seq>::List List; DISPLAY(List);
typedef Split<Seq>::First First; DISPLAY(First);
typedef Split<Seq>::Tail Tail; DISPLAY(Tail);
typedef Split<Seq>::Prefix Prefix; DISPLAY(Prefix);
typedef Split<Seq>::Last Last; DISPLAY(Last);
using List = Split<Seq>::List; DISPLAY(List);
using First = Split<Seq>::First; DISPLAY(First);
using Tail = Split<Seq>::Tail; DISPLAY(Tail);
using Prefix = Split<Seq>::Prefix; DISPLAY(Prefix);
using Last = Split<Seq>::Last; DISPLAY(Last);
typedef Split<Seq>::Head Head;
typedef Split<Seq>::End End;
using Head = Split<Seq>::Head;
using End = Split<Seq>::End;
typedef TyOLD<Head,End> HeadEnd; DISPLAY(HeadEnd);
using HeadEnd = TyOLD<Head,End>; DISPLAY(HeadEnd);
}

4
tests/library/parse-test.cpp
View file

@ -727,13 +727,13 @@ namespace test {
auto quoted = accept_repeated(accept(nonQuot).alt(escape));
auto quote = accept_bracket("\"\"", quoted);
auto paren = expectResult<NullType>();
auto paren = expectResult<Nil>();
auto nonParen = accept(R"_([^\\\(\)"]+)_");
auto parenCont = accept_repeated(accept(nonParen)
.alt(escape)
.alt(quote)
.alt(paren));
paren = accept_bracket("()", parenCont).bind([](auto){ return NullType{}; });
paren = accept_bracket("()", parenCont).bind([](auto){ return Nil{}; });
auto spec = accept_repeated(accept(content)
.alt(escape)

2
tests/vault/gear/activity-detector.hpp
View file

@ -294,7 +294,7 @@ namespace test {
{
using Ret = typename lib::meta::_Fun<SIG>::Ret;
using Args = typename lib::meta::_Fun<SIG>::Args;
using ArgsX = typename lib::meta::StripNullType<Args>::Seq; ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic
using ArgsX = typename lib::meta::StripNil<Args>::Seq; ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic
using SigTypes = typename lib::meta::Prepend<Ret, ArgsX>::Seq;
using Type = typename RebindVariadic<DiagnosticFun, SigTypes>::Type;