[コンパイル時計算]Dartでコンパイル時に計算を行うコンストラクタの例;実用的なものも色々あります。

関連するページ>>

https://qiita.com/riz21/items/c4144b5d2f18898e6ac8

https://qiita.com/riz21/items/e17048c6107968e13cd0
## 値の分岐を実現するクラス

<details><summary>返す値を分岐するクラス</summary>

```dart:const.dart
///a?b:cの方が良い
class IF<T>{
  const IF(bool bool_v,T a,[T? b]):v=bool_v?a:b;//bは未指定だと当然nullになる
  final T? v;
}
///bool_v?a:b;;bool_v?a:b0==false?b:v0;;bool_v?a:b0==false?b:b1==false?v0:v1;;の様な値の分岐をコンパイル時に計算し、実現する;
class IFs<T>{
  const IFs(bool bool_v,T a,[T? b,bool?b0,T?v0,bool?b1,T?v1,bool?b2,T?v2,bool?b3,T?v3]):v=
    bool_v?a:
    b0==null?b:b0==false?b:
    b1==null?v0:b1==false?v0:
    b2==null?v1:b2==false?v1:
    b3==null?v2:b3==false?v2:
    v3;
  final T? v;
}
```
</details>

## boolをコンパイル時に扱うクラス

<details><summary>全てがtrueならtrueを返す</summary>

```dart:const.dart
class ALL_AND {//全てがtrueならtrueを返す;コンパイル時に計算する
    const ALL_AND(bool t0,[bool?t1,bool?t2,bool?t3,bool?t4,bool?t5,bool?t6,bool?t7,bool?t8,bool?t9]):v=
    t0==false?false:
    t1==null?true:t1==false?false:
    t2==null?true:t2==false?false:
    t3==null?true:t3==false?false:
    t4==null?true:t4==false?false:
    t5==null?true:t5==false?false:
    t6==null?true:t6==false?false:
    t7==null?true:t7==false?false:
    t8==null?true:t8==false?false:
    t9==null?true:t9;
  final bool v;
}
```
</details>

<details><summary>全てがfalseならfalseを返す</summary>

```dart:const.dart
class ALL_OR {//全てがfalseならfalseを返す;コンパイル時に計算
    const ALL_OR(bool t0,[bool?t1,bool?t2,bool?t3,bool?t4,bool?t5,bool?t6,bool?t7,bool?t8,bool?t9]):v=
    t0==true?true:
    t1==null?false:t1==true?true:
    t2==null?false:t2==true?true:
    t3==null?false:t3==true?true:
    t4==null?false:t4==true?true:
    t5==null?false:t5==true?true:
    t6==null?false:t6==true?true:
    t7==null?false:t7==true?true:
    t8==null?false:t8==true?true:
    t9==null?false:t9;
  final bool v;
}
```
</details>

<details><summary>trueの数をカウント</summary>

```dart:const.dart
class BOOL_COUNT {//trueの数をカウント;コンパイル時に計算
    const BOOL_COUNT(bool t0,[bool?t1,bool?t2,bool?t3,bool?t4,bool?t5,bool?t6,bool?t7,bool?t8,bool?t9,bool?t10,bool?t11]):v=
    (t0?1:0)+
    (t1==null?0:(t1?1:0)+
    (t2==null?0:(t2?1:0)+
    (t3==null?0:(t3?1:0)+
    (t4==null?0:(t4?1:0)+
    (t5==null?0:(t5?1:0)+
    (t6==null?0:(t6?1:0)+
    (t7==null?0:(t7?1:0)+
    (t8==null?0:(t8?1:0)+
    (t9==null?0:(t9?1:0)+
    (t10==null?0:(t10?1:0)+
    (t11==null?0:(t11?1:0))))))))))));
  final int v;
}
```
</details>
<details><summary>boolの集合をbitmapで解釈し、intに変換</summary>

```dart:const.dart
class BOOL_TO_BITMAP {//boolの集合をbitmapで解釈し、intに変換;コンパイル時に計算する
    const BOOL_TO_BITMAP(bool t0,[bool?t1,bool?t2,bool?t3,bool?t4,bool?t5,bool?t6,bool?t7,bool?t8,bool?t9,bool?t10,bool?t11]):v=
    (t0?1:0)+
    (t1==null?0:(t1?2:0)+
    (t2==null?0:(t2?4:0)+
    (t3==null?0:(t3?8:0)+
    (t4==null?0:(t4?0x10:0)+
    (t5==null?0:(t5?0x20:0)+
    (t6==null?0:(t6?0x40:0)+
    (t7==null?0:(t7?0x80:0)+
    (t8==null?0:(t8?0x100:0)+
    (t9==null?0:(t9?0x200:0))+
    (t10==null?0:(t10?0x400:0))+
    (t11==null?0:(t11?0x800:0))))))))));
  final int v;
}
```
</details>

## intをコンパイル時に計算するクラス

<details><summary>基本の計算</summary>

```dart:const.dart
class addition{
  const addition(a,b):v=a+b;
  final num v;
}
class subtraction{
  const subtraction(a,b):v=a-b;
  final num v;
}
class multiplication{
  const multiplication(a,b):v=a*b;
  final num v;
}
class division{
  const division(a,b):v=a/b;
  final num v;
}
class divisionInt{
  const divisionInt(a,b):v=a~/b;
  final int v;
}
class dividend{
  const dividend(a,b):v=a%b;
  final num v;
}
```
</details>
<details><summary>べき乗</summary>

```dart:const.dart
class exponentiation{//べき乗;a^8が上限だが余裕で拡張可能
  const exponentiation(a,int b):v=//演算順序に注意!!括弧を外すと想定通りに動きません。
    1*(b<=0?1:
    a*(b<=1?1:
    a*(b<=2?1:
    a*(b<=3?1:
    a*(b<=4?1:
    a*(b<=5?1:
    a*(b<=6?1:
    a*(b<=7?1:a))))))));
  final num v;
}
```
</details>

## 型を扱う
<details><summary>キャストを試す</summary>

```dart:const.dart
///コンパイル時に;iをUにキャストしようとする。できなければ、uを返す;コンパイル時なら、コストを無視できる。
class AS<U>{
  const AS(dynamic i,U u):v=i is U?i:u;
  final U v;
}
```
</details>

## 複数の引数から検索など
<details><summary>tに該当する要素が存在するindexを返す</summary>

```dart:const.dart
///tに該当する要素があるindexをvに格納。等価がなければdef(-1がデフォ);重複する要素がtnに指定された場合に後ろの要素が該当することはないので、名前引数版は無い
class HRSWITCH3<T>{
  const HRSWITCH3(T t,[int def=-1,T?t0,T?t1,T?t2]):v=
    t==t0?0:t==t1?1:
    t==t2?2:def;
  final int v;
}
```
</details>
<details><summary>指定したindexにある値</summary>

「const[9,108,2020][1]」に軽さで負けているが、こっちの方が色々処理を変えれる
```dart:const.dart
///iが指定したindexの要素になる。その要素がnullだったり、iが範囲外だった時にdefの値になる;
class HSWITCH3<T>{
  const HSWITCH3(int i,T?def,[T?t0,T?t1,T?t2]):v=//配列アクセスが、定数コンストラクタでは行えないのでこうして実装する
    i==0?t0==null?def:t0:
    i==1?t1==null?def:t1:
    i==2?t2==null?def:t2:
    def;
  final T?v;
}
```
</details>