├── .clang-format
├── .gitignore
├── .tm_properties
├── CMakeLists.txt
├── LICENSE
├── README.md
├── cmake
    ├── colors.cmake
    ├── coverage.cmake
    └── pedantic.cmake
├── examples
    ├── CMakeLists.txt
    ├── test-single-header.cpp
    └── test.cpp
├── shorty.cpp
├── single-header
    ├── CMakeLists.txt
    ├── generate.cmake
    ├── shorty.hpp
    └── shorty.hpp.in
└── source
    ├── CMakeLists.txt
    └── shorty
        ├── compatibility
            ├── concepts.cppm
            ├── concepts.hpp
            ├── pack-indexing.cppm
            └── pack-indexing.hpp
        ├── leaves.cppm
        ├── leaves.hpp
        ├── literals.cppm
        ├── literals.hpp
        ├── ops.cppm
        ├── ops.hpp
        ├── shorty.cppm
        └── shorty.hpp


/.clang-format:
--------------------------------------------------------------------------------
  1 | ---
  2 | Language:        Cpp
  3 | # BasedOnStyle:  WebKit
  4 | AccessModifierOffset: -4
  5 | AlignAfterOpenBracket: DontAlign
  6 | AlignConsecutiveMacros: None
  7 | AlignConsecutiveAssignments: None
  8 | AlignConsecutiveBitFields: None
  9 | AlignConsecutiveDeclarations: None
 10 | AlignEscapedNewlines: Right
 11 | AlignOperands:   DontAlign
 12 | AlignTrailingComments: true
 13 | AllowAllArgumentsOnNextLine: true
 14 | AllowAllConstructorInitializersOnNextLine: true
 15 | AllowAllParametersOfDeclarationOnNextLine: true
 16 | AllowShortEnumsOnASingleLine: true
 17 | AllowShortBlocksOnASingleLine: Always
 18 | AllowShortCaseLabelsOnASingleLine: false
 19 | AllowShortFunctionsOnASingleLine: All
 20 | AllowShortLambdasOnASingleLine: All
 21 | AllowShortIfStatementsOnASingleLine: Always
 22 | AllowShortLoopsOnASingleLine: true
 23 | AlwaysBreakAfterDefinitionReturnType: None
 24 | AlwaysBreakAfterReturnType: None
 25 | AlwaysBreakBeforeMultilineStrings: true
 26 | AlwaysBreakTemplateDeclarations: No
 27 | AttributeMacros:
 28 |   - __capability
 29 | BinPackArguments: true
 30 | BinPackParameters: true
 31 | BraceWrapping:
 32 |   AfterCaseLabel:  false
 33 |   AfterClass:      false
 34 |   AfterControlStatement: Never
 35 |   AfterEnum:       false
 36 |   AfterFunction:   false
 37 |   AfterNamespace:  false
 38 |   AfterObjCDeclaration: false
 39 |   AfterStruct:     false
 40 |   AfterUnion:      false
 41 |   AfterExternBlock: false
 42 |   BeforeCatch:     false
 43 |   BeforeElse:      false
 44 |   BeforeLambdaBody: false
 45 |   BeforeWhile:     false
 46 |   IndentBraces:    false
 47 |   SplitEmptyFunction: false
 48 |   SplitEmptyRecord: false
 49 |   SplitEmptyNamespace: false
 50 | BreakBeforeBinaryOperators: All
 51 | BreakBeforeConceptDeclarations: false
 52 | BreakBeforeBraces: Attach
 53 | BreakBeforeInheritanceComma: false
 54 | BreakInheritanceList: BeforeColon
 55 | BreakBeforeTernaryOperators: true
 56 | BreakConstructorInitializersBeforeComma: false
 57 | BreakAfterJavaFieldAnnotations: false
 58 | BreakStringLiterals: true
 59 | ColumnLimit:     0
 60 | CommentPragmas:  '^ IWYU pragma:'
 61 | CompactNamespaces: false
 62 | ConstructorInitializerAllOnOneLineOrOnePerLine: false
 63 | ConstructorInitializerIndentWidth: 4
 64 | ContinuationIndentWidth: 4
 65 | Cpp11BracedListStyle: true
 66 | DeriveLineEnding: true
 67 | DerivePointerAlignment: false
 68 | DisableFormat:   false
 69 | EmptyLineBeforeAccessModifier: LogicalBlock
 70 | ExperimentalAutoDetectBinPacking: false
 71 | FixNamespaceComments: true
 72 | ForEachMacros:
 73 |   - foreach
 74 |   - Q_FOREACH
 75 |   - BOOST_FOREACH
 76 | StatementAttributeLikeMacros:
 77 |   - Q_EMIT
 78 | IncludeBlocks:   Merge
 79 | IncludeCategories:
 80 |   - Regex:           '^<version>$'
 81 |     Priority:        3
 82 |     SortPriority:    0
 83 |     CaseSensitive:   false
 84 |   - Regex:           '^<shorty/.+>$'
 85 |     Priority:        0
 86 |     SortPriority:    0
 87 |     CaseSensitive:   false
 88 |   - Regex:           '^<catch2/.+>$'
 89 |     Priority:        1
 90 |     SortPriority:    0
 91 |     CaseSensitive:   false
 92 |   - Regex:           '^".+/.+"$'
 93 |     Priority:        2
 94 |     SortPriority:    0
 95 |     CaseSensitive:   false
 96 |   - Regex:           '^".+"$'
 97 |     Priority:        1
 98 |     SortPriority:    0
 99 |     CaseSensitive:   false
100 |   - Regex:           '^<windows.h>$'
101 |     Priority:        4
102 |     SortPriority:    0
103 |     CaseSensitive:   false
104 |   - Regex:           '^<(c[^.]+|.+\.h)>$'
105 |     Priority:        8
106 |     SortPriority:    0
107 |     CaseSensitive:   false
108 |   - Regex:           '^<.+>$'
109 |     Priority:        7
110 |     SortPriority:    0
111 |     CaseSensitive:   false
112 | IncludeIsMainRegex: '(Test)?$'
113 | IncludeIsMainSourceRegex: ''
114 | IndentCaseLabels: false
115 | IndentCaseBlocks: false
116 | IndentGotoLabels: true
117 | IndentPPDirectives: None
118 | IndentExternBlock: AfterExternBlock
119 | IndentRequires:  false
120 | IndentWidth:     4
121 | IndentWrappedFunctionNames: false
122 | InsertTrailingCommas: None
123 | JavaScriptQuotes: Leave
124 | JavaScriptWrapImports: true
125 | KeepEmptyLinesAtTheStartOfBlocks: false
126 | LambdaBodyIndentation: OuterScope
127 | MacroBlockBegin: ''
128 | MacroBlockEnd:   ''
129 | MaxEmptyLinesToKeep: 1
130 | NamespaceIndentation: Inner
131 | PenaltyBreakAssignment: 2
132 | PenaltyBreakBeforeFirstCallParameter: 19
133 | PenaltyBreakComment: 300
134 | PenaltyBreakFirstLessLess: 120
135 | PenaltyBreakString: 1000
136 | PenaltyBreakTemplateDeclaration: 10
137 | PenaltyExcessCharacter: 1000000
138 | PenaltyReturnTypeOnItsOwnLine: 60
139 | PenaltyIndentedWhitespace: 0
140 | PointerAlignment: Middle
141 | ReflowComments:  true
142 | RequiresClausePosition: SingleLine
143 | SortIncludes:    true
144 | SortJavaStaticImport: Before
145 | SortUsingDeclarations: true
146 | SpaceAfterCStyleCast: false
147 | SpaceAfterLogicalNot: false
148 | SpaceAfterTemplateKeyword: true
149 | SpaceBeforeAssignmentOperators: true
150 | SpaceBeforeCaseColon: false
151 | SpaceBeforeCpp11BracedList: false
152 | SpaceBeforeCtorInitializerColon: false
153 | SpaceBeforeInheritanceColon: false
154 | SpaceBeforeParens: ControlStatements
155 | SpaceAroundPointerQualifiers: Both
156 | SpaceBeforeRangeBasedForLoopColon: false
157 | SpaceInEmptyBlock: true
158 | SpaceInEmptyParentheses: false
159 | SpacesBeforeTrailingComments: 1
160 | SpacesInAngles:  false
161 | SpacesInConditionalStatement: false
162 | SpacesInContainerLiterals: false
163 | SpacesInCStyleCastParentheses: false
164 | SpacesInParentheses: false
165 | SpacesInSquareBrackets: false
166 | SpaceBeforeSquareBrackets: false
167 | BitFieldColonSpacing: After
168 | Standard:        c++20
169 | TabWidth:        4
170 | UseCRLF:         false
171 | UseTab:          Always
172 | WhitespaceSensitiveMacros: []
173 | 
174 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build*


--------------------------------------------------------------------------------
/.tm_properties:
--------------------------------------------------------------------------------
 1 | CLANG_FORMAT_ON_SAVE = true
 2 | 
 3 | excludeDirectories = "{$excludeDirectories,build}"
 4 | includeDirectories = "{$includeDirectories}"
 5 | include = "{$include,.gitignore,.gitattributes,.clang-format,.github}"
 6 | excludeInFolderSearch = "{$excludeInFolderSearch,build,external,*-single-header.hpp}" 
 7 | includeInFolderSearch = "{$includeInFolderSearch}"
 8 | excludeInFileChooser = "{$excludeInFileChooser}" 
 9 | softTabs = false
10 | tabSize = 2
11 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 4.0)
 2 | 
 3 | list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 4 | 
 5 | option(SHORTY_IS_IN_MODULE "build shorty library as a c++ module" ON)
 6 | 
 7 | if (SHORTY_IS_IN_MODULE)
 8 | set(CMAKE_CXX_STANDARD 23)
 9 | set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "a9e1cf81-9932-4810-974b-6eccaf14e457")
10 | set(CMAKE_COLOR_DIAGNOSTICS ON)
11 | 
12 | set(CMAKE_CXX_STANDARD_REQUIRED OFF)
13 | set(CMAKE_CXX_MODULE_STD 1)
14 | endif()
15 | 
16 | include(colors)
17 | include(pedantic)
18 | 
19 | project(shorty VERSION 1.0 LANGUAGES CXX)
20 | 
21 | add_subdirectory(source)
22 | add_subdirectory(single-header EXCLUDE_FROM_ALL)
23 | add_subdirectory(examples EXCLUDE_FROM_ALL)
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |     TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |     1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |     2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |     3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |     4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |     5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |     6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |     7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |     8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |     9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |     END OF TERMS AND CONDITIONS
177 | 
178 |     APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |     Copyright [yyyy] [name of copyright owner]
190 | 
191 |     Licensed under the Apache License, Version 2.0 (the "License");
192 |     you may not use this file except in compliance with the License.
193 |     You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |     Unless required by applicable law or agreed to in writing, software
198 |     distributed under the License is distributed on an "AS IS" BASIS,
199 |     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |     See the License for the specific language governing permissions and
201 |     limitations under the License.
202 | 
203 | 
204 | --- LLVM Exceptions to the Apache 2.0 License ----
205 | 
206 | As an exception, if, as a result of your compiling your source code, portions
207 | of this Software are embedded into an Object form of such source code, you
208 | may redistribute such embedded portions in such Object form without complying
209 | with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
210 | 
211 | In addition, if you combine or link compiled forms of this Software with
212 | software that is licensed under the GPLv2 ("Combined Software") and if a
213 | court of competent jurisdiction determines that the patent provision (Section
214 | 3), the indemnity provision (Section 9) or other Section of the License
215 | conflicts with the conditions of the GPLv2, you may retroactively and
216 | prospectively choose to deem waived or otherwise exclude such Section(s) of
217 | the License, but only in their entirety and only with respect to the Combined
218 | Software.
219 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # terser (shorter) lambda == SHORTY
 2 | 
 3 | This library is intended to give terser syntax than C++'s lambdas, not replace C++ with lazy DSL.
 4 | 
 5 | ```c++
 6 | import shorty;
 7 | using namespace shorty::literals;
 8 | 
 9 | // you no longer need to remember if it's `std::less` or `std::greater`
10 | std::ranges::sort(subject, $lhs > $rhs);
11 | 
12 | // filter only even
13 | subject | std::views::filter(($i % 2) == 0);
14 | 
15 | // zip together and transform
16 | std::views::zip(A,B,C,D) | std::views::transform($a * $b + $c * $d);
17 | 
18 | // call external function
19 | auto pythagorean = $<sqrt>($a * $a + $b * $b); // or $call<sqrt>;
20 | pythagorean(3.0, 4.0) == 5.0;
21 | 
22 | // casting
23 | auto to_int = $<int>($0); // or $cast<int>;
24 | to_int(4.3) == 4; 
25 | 
26 | // remap by index
27 | auto indices = std::vector<int>{...};
28 | auto mapping = indices | $(data)[$i];
29 | ```
30 | 
31 | ## accessing arguments
32 | 
33 | If shorty callable gets only one argument and the argument is `tuple_like` then it's automatically unwrapped. Same applies to any lazy calls.
34 | 
35 | By default arguments are accessible using `$0`...`$9` syntax (for first 10) or `$arg<N>`. But also you can use following special arguments:
36 | 
37 | - `$lhs` and `$rhs` for binary callables (it limits them to two arguments)
38 | - `$it` for first and only argument, which is also compatible with `std::input_or_output_iterator`
39 | - `$a` ... `$f` for first 6 arguments but names instead of numbers (can't be mixed with other types of arguments)
40 | - `$x`, `$y`, `$z` for first 3 arguments (again can't be mixed with other types of arguments)
41 | - `$i`, `$n`, `$k`, `$in` ... for first and only argument (can't be mixed too)
42 | 
43 | ## querying arguments
44 | 
45 | - `$argc` for getting number of arguments as `size_t`
46 | - `$args` to get all arguments as a tuple
47 | 
48 | ## capturing
49 | 
50 | - `$(v)` or `$ref(v)` capture by reference (or const reference, depending on const qualifier of `v`)
51 | - `$value(v)`, `$val(v)`, or `$copy(v)` capture by copy
52 | - `$fixed<v>` or `$const<v>` capture by CNTTP (only for structural types)
53 | 
54 | ## calling functions
55 | 
56 | - `$<callable>(args...)` or `$call<callable>(args...)` call `callable` with arguments `args`
57 | - `$<CallableType>(args...)` or `$call<CallableType>(args...)` call new instance of type `CallableType` with arguments `args`
58 | 
59 | ## casting
60 | 
61 | - `$<T>(expr)` or `$cast<T>(expr)` will `static_cast` expression result into `T`
62 | 	
63 | ## making a tuple
64 | 
65 | - `($a, $b, $c)` - will make `tuple<auto,auto,auto>`
66 | - `($0, $1)` - will make `tuple<auto,auto>`
67 | 
68 | ## assigning
69 | 
70 | - `$a += 2` will add 2 to `$a` and return result
71 | - `-=`, `*=`, `/=`, `%=` all works too
72 | 
73 | ----
74 | 
75 | Special thanks (and a bit of hate) to an [anonymous Argentinian](https://bsky.app/profile/kaballo86.bsky.social) for nerd-sniping into this.
76 | 


--------------------------------------------------------------------------------
/cmake/colors.cmake:
--------------------------------------------------------------------------------
 1 | option (FORCE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." ON)
 2 | if (${FORCE_COLORED_OUTPUT})
 3 | 	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 4 | 		add_compile_options ($<$<COMPILE_LANGUAGE:C>:-fdiagnostics-color=always>)
 5 | 		add_compile_options ($<$<COMPILE_LANGUAGE:CXX>:-fdiagnostics-color=always>)
 6 | 	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 7 | 		add_compile_options ($<$<COMPILE_LANGUAGE:C>:-fcolor-diagnostics>)
 8 | 		add_compile_options ($<$<COMPILE_LANGUAGE:CXX>:-fcolor-diagnostics>)
 9 | 	endif ()
10 | endif ()


--------------------------------------------------------------------------------
/cmake/coverage.cmake:
--------------------------------------------------------------------------------
 1 | SET(test_source "int main() { }")
 2 | 
 3 | try_compile(COVERAGE_WORKS SOURCE_FROM_VAR test.cpp test_source LINK_OPTIONS -fprofile-instr-generate -fcoverage-mapping OUTPUT_VARIABLE COVERAGE_WORKS_OUTPUT)
 4 | 
 5 | if (NOT COVERAGE_WORKS)
 6 | 	#message(STATUS "test coverage is not compatible with current compiler")
 7 | 	#message(STATUS "${COVERAGE_WORKS_OUTPUT}")
 8 | 	function(enable_coverage)
 9 | 	endfunction()
10 | 	
11 | 	function(coverage_report_after EVENT TARGET)
12 | 		add_custom_target(coverage DEPENDS ${EVENT})
13 | 	endfunction()
14 | 	
15 | 	unset(LLVM_COV)
16 | 	return()
17 | endif()
18 | 
19 | cmake_path(GET CMAKE_CXX_COMPILER PARENT_PATH COMPILER_HINT_PATH)
20 | 
21 | if (NOT LLVM_PROFDATA)
22 | 	find_program(LLVM_PROFDATA llvm-profdata HINTS ${COMPILER_HINT_PATH})
23 | endif()
24 | 
25 | if (NOT LLVM_COV)
26 | 	find_program(LLVM_COV llvm-cov HINTS ${COMPILER_HINT_PATH})
27 | endif()
28 | 
29 | if (LLVM_PROFDATA AND LLVM_COV)
30 | 	set(LLVM_PROFDATA "${LLVM_PROFDATA}" CACHE INTERNAL "path to llvm-profdata")
31 | 	set(LLVM_COV "${LLVM_COV}" CACHE INTERNAL "path to llvm-cov")
32 | else()
33 | 	find_program(XCRUN xcrun)
34 | 	if (XCRUN)
35 | 		set(LLVM_PROFDATA "${XCRUN} llvm-profdata" CACHE INTERNAL "path to llvm-profdata")
36 | 		set(LLVM_COV "${XCRUN} llvm-cov" CACHE INTERNAL "path to llvm-cov")
37 | 	endif()
38 | endif()
39 | 
40 | find_program(OPEN_UTILITY open)
41 | set(OPEN_UTILITY "${OPEN_UTILITY}" CACHE INTERNAL "path to open utility")
42 | 
43 | function(enable_coverage)
44 | 	
45 | 	if (NOT COVERAGE_WORKS)
46 | 		message(FATAL_ERROR "Source level code coverage is not supporter!")
47 | 	endif()
48 | 	
49 | 	if (NOT LLVM_COV)
50 | 		message(FATAL_ERROR "Source level code coverage is supported only for Clang compiler! (CMAKE_CXX_COMPILER_ID = ${CMAKE_CXX_COMPILER_ID})")
51 | 	endif()
52 | 	
53 | 	message(STATUS "Enabling Clang source code-coverage (llvm-cov=${LLVM_COV})")
54 | 	
55 | 	# add flags to emit coverage
56 | 	add_compile_options("-fprofile-instr-generate" "-fcoverage-mapping" "-g")
57 | 	add_link_options("-fprofile-instr-generate" "-fcoverage-mapping")
58 | 	add_compile_options("-ffile-prefix-map=${CMAKE_SOURCE_DIR}/=/")
59 | endfunction()
60 | 
61 | function(coverage_report_after EVENT TARGET)
62 | 	if (NOT LLVM_COV)
63 | 		add_custom_target(coverage DEPENDS ${EVENT})
64 | 		return()
65 | 	endif()
66 | 
67 | 	SET(coverage_data_name "default.profraw")
68 | 	add_custom_command(TARGET ${EVENT} POST_BUILD 
69 | 		COMMAND ${LLVM_PROFDATA} merge -sparse ${coverage_data_name} -o coverage.profdata 
70 | 		COMMAND ${LLVM_COV} show $<TARGET_FILE:${TARGET}> -format html -instr-profile=coverage.profdata "-ignore-filename-regex=\"(external/.*|tests/.*|cthash/internal/assert[.]hpp)\""  -output-dir ${CMAKE_BINARY_DIR}/report -show-instantiations=false -show-directory-coverage -show-expansions=false -show-line-counts --show-line-counts-or-regions -Xdemangler c++filt -Xdemangler -n -show-branches=percent -tab-size=4 -path-equivalence=/,${CMAKE_SOURCE_DIR} 
71 | 		COMMAND cd ${CMAKE_BINARY_DIR} && zip -q -r -9 report.zip report BYPRODUCTS  ${CMAKE_BINARY_DIR}/report.zip COMMENT "Generating Code-Coverage report"
72 | 	)
73 | 	
74 | 	add_custom_target(coverage DEPENDS ${CMAKE_BINARY_DIR}/report.zip)
75 | 	
76 | 	if (OPEN_UTILITY)
77 | 		add_custom_command(TARGET coverage POST_BUILD COMMAND ${OPEN_UTILITY} ${CMAKE_BINARY_DIR}/report/index.html DEPENDS ${CMAKE_BINARY_DIR}/report.zip)
78 | 	endif()
79 | endfunction()
80 | 


--------------------------------------------------------------------------------
/cmake/pedantic.cmake:
--------------------------------------------------------------------------------
 1 | macro(add_c_and_cxx_compile_options NAME)
 2 | 	add_compile_options("$<$<COMPILE_LANGUAGE:C>:${NAME}>")
 3 | 	add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:${NAME}>")
 4 | endmacro()
 5 | 
 6 | macro(add_c_and_cxx_compile_definitions NAME)
 7 | 	add_compile_definitions("$<$<COMPILE_LANGUAGE:C>:${NAME}>")
 8 | 	add_compile_definitions("$<$<COMPILE_LANGUAGE:CXX>:${NAME}>")
 9 | endmacro()
10 | 
11 | if (MSVC)
12 | 	add_c_and_cxx_compile_options("/W4")
13 | 	add_c_and_cxx_compile_options("/WX")
14 | else()
15 | 	add_c_and_cxx_compile_options("-Wall")
16 | 	add_c_and_cxx_compile_options("-Wextra")
17 | 	add_c_and_cxx_compile_options("-pedantic")
18 | 	add_c_and_cxx_compile_options("-Wshadow")
19 | 	add_c_and_cxx_compile_options("-Wconversion")
20 | 	add_c_and_cxx_compile_options("-Werror")
21 | 	add_c_and_cxx_compile_options("-Wno-dollar-in-identifier-extension")
22 | 	
23 | 	if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
24 | 		add_c_and_cxx_compile_definitions("_LIBCPP_ENABLE_NODISCARD")
25 | 		
26 | 		if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
27 | 			add_c_and_cxx_compile_options("-Wno-missing-braces")
28 | 		endif()
29 | 	elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
30 | 		add_c_and_cxx_compile_definitions("_LIBCPP_ENABLE_NODISCARD")
31 | 		add_c_and_cxx_compile_options("-Wno-missing-braces")
32 | 	endif()
33 | endif()
34 | 


--------------------------------------------------------------------------------
/examples/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable(test test.cpp)
2 | target_link_libraries(test PRIVATE shorty)
3 | 
4 | add_executable(test-single-header test-single-header.cpp)
5 | target_link_libraries(test-single-header PRIVATE shorty-single-header)
6 | 
7 | add_custom_target(examples DEPENDS test test-single-header)
8 | 


--------------------------------------------------------------------------------
/examples/test-single-header.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <print>
 3 | #include <ranges>
 4 | #include <shorty.hpp>
 5 | 
 6 | int main() {
 7 | 	using namespace shorty::literals;
 8 | 
 9 | 	auto data = std::array{1, 2, 3, 4, 5};
10 | 	auto indices = std::array{0, 0, 4, 4, 1};
11 | 
12 | 	std::ranges::sort(indices, $lhs < $rhs);
13 | 
14 | 	for (auto v: indices | std::views::transform($(data)[$<size_t>($0)])) {
15 | 		std::println("{}", v);
16 | 	}
17 | 
18 | 	std::println("zip:");
19 | 	auto a = std::array{1, 2, 3, 4, 5};
20 | 	auto b = std::array{2, 0, 1, 1, 3};
21 | 	for (auto v: std::views::zip(a, b) | std::views::transform($0 + $1)) {
22 | 		std::println("{}", v);
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/examples/test.cpp:
--------------------------------------------------------------------------------
 1 | #ifdef SHORTY_IS_IN_MODULE
 2 | import shorty;
 3 | import std;
 4 | #else
 5 | #include <shorty/shorty.hpp>
 6 | #include <algorithm>
 7 | #include <print>
 8 | #include <ranges>
 9 | #endif
10 | 
11 | #include <cassert>
12 | 
13 | int main() {
14 | 	using namespace shorty::literals;
15 | 
16 | 	auto data = std::array{1, 2, 3, 4, 5};
17 | 	std::ranges::sort(data, $lhs < $rhs);
18 | 
19 | 	auto indices = std::array{0, 0, 4, 4, 1};
20 | 	for (auto v: indices | std::views::transform($(data)[$0])) {
21 | 		std::println("{}", v);
22 | 	}
23 | 
24 | 	std::println("zip:");
25 | 	auto a = std::array{1, 2, 3, 4, 5};
26 | 	auto b = std::array{2, 0, 1, 1, 3};
27 | 	auto c = std::array{1, 1, 1, 0, 1};
28 | 	for (auto v: std::views::zip(a, b, c) | std::views::transform(($a + $b) * $c)) {
29 | 		std::println("{}", v);
30 | 	}
31 | 
32 | 	std::println("squares:");
33 | 	constexpr auto sqrt = [](std::floating_point auto v) {
34 | 		return std::sqrt(v);
35 | 	};
36 | 
37 | 	auto values = std::array{1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
38 | 	for (auto v: values | std::views::transform($<sqrt>($0))) {
39 | 		std::println("{}", v);
40 | 	}
41 | 
42 | 	[[maybe_unused]] auto cast_to_int = $<int>($0);
43 | 	assert(cast_to_int(42.3) == 42);
44 | 
45 | 	// auto wrong_expr = $x + $a;
46 | 	auto expr = $0 + $1;
47 | 	assert(expr(1, 4) == 5);
48 | 
49 | 	auto make_tuple = ($0, $1, $2);
50 | 	std::tuple<int, int, int> r = make_tuple(1, 2, 3);
51 | 	auto [t0, t1, t2] = r;
52 | 	assert(t0 == 1);
53 | 	assert(t1 == 2);
54 | 	assert(t2 == 3);
55 | 
56 | 	constexpr auto sum = [](shorty::tuple_like auto && tpl) {
57 | 		return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
58 | 			return (std::get<Idx>(tpl) + ... + 0);
59 | 		}(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<decltype(tpl)>>>());
60 | 	};
61 | 
62 | 	auto test = $<sum>(($0, $1, $2, $3)); // double paranthesis are explicit, so we get tuple
63 | 	auto r2 = test(1, 2, 3, 4);
64 | 	std::println("{} == 10", r2);
65 | 
66 | 	// identify<decltype(r)> i;
67 | 	//  expr(1, 2);
68 | 	//  expr(std::tuple{1});
69 | 
70 | 	// auto expr2 = $lhs + $x;
71 | }


--------------------------------------------------------------------------------
/shorty.cpp:
--------------------------------------------------------------------------------
  1 | #include <functional>
  2 | #include <ranges>
  3 | #include <tuple>
  4 | #include <utility>
  5 | #include <concepts>
  6 | 
  7 | namespace shorty {
  8 | 
  9 | struct ast_node { };
 10 | 
 11 | #if __cpp_pack_indexing < 202311L
 12 | template <size_t N, typename First, typename... Args> constexpr auto extract_nth(First && first, Args &&... args) noexcept {
 13 | 	if constexpr (N == 0u) {
 14 | 		return first;
 15 | 	} else {
 16 | 		return extract_nth<N - 1u>(std::forward<Args>(args)...);
 17 | 	}
 18 | }
 19 | #endif
 20 | 
 21 | template <unsigned N> struct nth_argument {
 22 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
 23 | 		static_assert(N < sizeof...(Args));
 24 | #if __cpp_pack_indexing >= 202311L
 25 | 		return args...[N];
 26 | #else
 27 | 		return extract_nth<N>(std::forward<Args>(args)...);
 28 | #endif
 29 | 	}
 30 | 	constexpr operator ast_node() const { return {}; }
 31 | };
 32 | 
 33 | template <unsigned N, unsigned Count> struct nth_argument_of_k {
 34 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
 35 | 		static_assert(Count == sizeof...(Args));
 36 | 		static_assert(N < sizeof...(Args));
 37 | #if __cpp_pack_indexing >= 202311L
 38 | 		return args...[N];
 39 | #else
 40 | 		return extract_nth<N>(std::forward<Args>(args)...);
 41 | #endif
 42 | 	}
 43 | 	constexpr operator ast_node() const { return {}; }
 44 | };
 45 | 
 46 | template <unsigned N, auto Query> struct nth_argument_with_query {
 47 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
 48 | 		static_assert(N < sizeof...(Args));
 49 | #if __cpp_pack_indexing >= 202311L
 50 | 		static_assert(Query(std::type_identity<Args... [N]> { }));
 51 | 		return args...[N];
 52 | #else
 53 | 		static_assert(Query(std::type_identity<decltype(extract_nth<N>(std::forward<Args>(args)...))>{}));
 54 | 		return extract_nth<N>(std::forward<Args>(args)...);
 55 | #endif
 56 | 	}
 57 | 	constexpr operator ast_node() const { return {}; }
 58 | };
 59 | 
 60 | struct argument_count {
 61 | 	template <typename... Args> constexpr auto operator()(Args &&...) const {
 62 | 		return sizeof...(Args);
 63 | 	}
 64 | 	constexpr operator ast_node() const { return {}; }
 65 | };
 66 | 
 67 | struct pack_arguments {
 68 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
 69 | 		return std::tuple(std::forward<Args>(args)...);
 70 | 	}
 71 | 	constexpr operator ast_node() const { return {}; }
 72 | };
 73 | 
 74 | template <auto V> struct constant {
 75 | 	template <typename... Args> constexpr auto operator()(Args &&...) const {
 76 | 		return V;
 77 | 	}
 78 | 	constexpr operator ast_node() const { return {}; }
 79 | };
 80 | 
 81 | template <typename T> struct value {
 82 | 	T & data;
 83 | 	template <typename... Args> constexpr auto operator()(Args &&...) const {
 84 | 		return data;
 85 | 	}
 86 | 	constexpr operator ast_node() const { return {}; }
 87 | };
 88 | 
 89 | template <typename CharT, size_t N> struct static_string {
 90 | 	using type = const CharT (&)[N];
 91 | 	type data;
 92 | 	consteval static_string(const CharT (&_data)[N]) noexcept: data{_data} { }
 93 | 	template <typename... Args> constexpr type operator()(Args &&...) const {
 94 | 		return data;
 95 | 	}
 96 | 	constexpr operator ast_node() const { return {}; }
 97 | };
 98 | 
 99 | template <typename T> struct reference {
100 | 	T & value;
101 | 	template <typename... Args> constexpr auto operator()(Args &&...) const {
102 | 		return value;
103 | 	}
104 | 	constexpr operator ast_node() const { return {}; }
105 | };
106 | 
107 | template <typename T, typename... Args> constexpr decltype(auto) evaluate(T && obj, [[maybe_unused]] Args &&... args) {
108 | 	if constexpr (requires {
109 | 					  obj(std::forward<Args>(args)...);
110 | 				  }) {
111 | 		return obj(std::forward<Args>(args)...);
112 | 	} else {
113 | 		return obj;
114 | 	}
115 | }
116 | 
117 | template <typename Op, typename... Operands> struct node {
118 | 	using base_node = node;
119 | 
120 | 	static constexpr auto op = Op{};
121 | 	[[no_unique_address]] std::tuple<Operands...> ast_operands;
122 | 
123 | 	node(node &&) = default;
124 | 	node(const node &) = default;
125 | 	constexpr node(std::convertible_to<Operands> auto &&... _ast_operands): ast_operands{std::forward<decltype(_ast_operands)>(_ast_operands)...} { }
126 | 
127 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
128 | #if __cpp_structured_bindings >= 202411L
129 | 		auto && [... operands] = ast_operands;
130 | 		return op(evaluate(std::forward<decltype(operands)>(operands), std::forward<Args>(args)...)...);
131 | #else
132 | 		return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
133 | 			return op(evaluate(std::get<Idx>(ast_operands), std::forward<Args>(args)...)...);
134 | 		}(std::make_index_sequence<std::tuple_size<decltype(ast_operands)>::value>());
135 | #endif
136 | 	}
137 | 
138 | 	constexpr operator ast_node() const { return {}; }
139 | };
140 | 
141 | template <typename T> concept is_node = requires(const T & maybe_node) {
142 | 	typename T::base_node;
143 | 	{ node{std::declval<T::base_node>()} } -> std::same_as<typename T::base_node>;
144 | 	{ node{maybe_node} } -> std::same_as<typename T::base_node>;
145 | };
146 | 
147 | // just to make sure nodes and arguments are not references
148 | // template <typename T, typename Y = T>  auto fix_type(std::remove_cvref_t<Y> *) -> std::remove_cvref_t<T>;
149 | 
150 | // everything else can be
151 | // template <typename Sink> auto fix_type(...) -> value<std::remove_reference_t<Sink>>;
152 | 
153 | template <typename T, typename Y = T> auto wrap(Y *) -> std::remove_cvref_t<T> requires std::convertible_to<std::remove_cvref_t<T>, ast_node>;
154 | 
155 | template <typename T> struct wrapper {
156 | 	using result = value<std::remove_cvref_t<T>>;
157 | };
158 | 
159 | template <typename CharT, size_t N> struct wrapper<const CharT (&)[N]> {
160 | 	using result = static_string<CharT, N>;
161 | };
162 | 
163 | template <std::convertible_to<ast_node> T> struct wrapper<T> {
164 | 	using result = std::remove_cvref_t<T>;
165 | };
166 | 
167 | // template <typename T> using select = decltype(fix_type<T>(nullptr));
168 | template <typename T> using select = wrapper<T>::result;
169 | 
170 | // SUPPORT FOR UNARY and BINARY OPS
171 | template <typename Op, typename A> struct unary_op: node<Op, A> { };
172 | template <typename Op, typename A, typename B> struct binary_op: node<Op, A, B> { };
173 | 
174 | template <typename Op> struct node_builder {
175 | 	template <typename... Args> constexpr auto operator()(Args &&... args) {
176 | 		if constexpr (sizeof...(Args) == 1) {
177 | 			return unary_op<Op, select<Args>...>(std::forward<Args>(args)...);
178 | 		} else if constexpr (sizeof...(Args) == 2) {
179 | 			return binary_op<Op, select<Args>...>(std::forward<Args>(args)...);
180 | 		} else {
181 | 			return node<Op, select<Args>...>(std::forward<Args>(args)...);
182 | 		}
183 | 	}
184 | };
185 | 
186 | template <typename Op> constexpr auto build = node_builder<Op>{};
187 | 
188 | // I wish I have the universal template arguments
189 | template <template <typename...> typename ExactNode> struct exact_node_builder {
190 | 	template <typename... Args> static constexpr auto operator()(Args &&... args) {
191 | 		using node_type = ExactNode<select<Args>...>::base_node;
192 | 		return ExactNode<select<Args>...>{node_type{std::forward<Args>(args)...}};
193 | 	}
194 | };
195 | 
196 | template <template <typename...> typename ExactNode> constexpr auto exact_build = exact_node_builder<ExactNode>{};
197 | 
198 | // CASTING
199 | template <typename T> struct cast_to {
200 | 	static constexpr auto operator()(auto && arg) {
201 | 		return static_cast<T>(arg);
202 | 	}
203 | };
204 | 
205 | template <typename T, typename A> struct cast_op: node<cast_to<T>, A> { };
206 | 
207 | template <typename T> constexpr auto cast(auto &&... args) {
208 | 	return cast_op<T, select<decltype(args)>...>(std::forward<decltype(args)>(args)...);
209 | }
210 | 
211 | template <auto Op> struct apply_at {
212 | 	template <typename... Ts> constexpr auto operator()(std::tuple<Ts...> && pack) const {
213 | #if __cpp_structured_bindings >= 202411L
214 | 		auto && [... args] = pack;
215 | 		static_assert(std::invocable<decltype(Op), decltype(args)...>);
216 | 		return Op(std::forward<decltype(args)>(args)...);
217 | #else
218 | 		return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
219 | 			static_assert(std::invocable<decltype(Op), decltype(std::get<Idx>(pack))...>);
220 | 			return Op(std::get<Idx>(pack)...);
221 | 		}(std::make_index_sequence<sizeof...(Ts)>());
222 | #endif
223 | 	}
224 | 
225 | 	template <typename... Args> constexpr auto operator()(Args &&... args) const {
226 | 		static_assert(std::invocable<decltype(Op), Args...>);
227 | 		return Op(std::forward<Args>(args)...);
228 | 	}
229 | };
230 | 
231 | template <auto Op, typename... Args> struct apply_at_op: node<apply_at<Op>, Args...> { };
232 | 
233 | template <auto Op> constexpr auto apply(auto &&... args) {
234 | 	return apply_at_op<Op, select<decltype(args)>...>(std::forward<decltype(args)>(args)...);
235 | }
236 | 
237 | // SUPPORT FOR RELATIONAL OPS
238 | template <auto Op> struct relational {
239 | 	static constexpr auto operator()(auto && lhs, auto && rhs) {
240 | 		if constexpr (Op == std::is_eq) {
241 | 			return std::forward<decltype(lhs)>(lhs) == std::forward<decltype(rhs)>(rhs);
242 | 		} else if constexpr (Op == std::is_neq) {
243 | 			return std::forward<decltype(lhs)>(lhs) != std::forward<decltype(rhs)>(rhs);
244 | 		} else {
245 | 			return Op(std::forward<decltype(lhs)>(lhs) <=> std::forward<decltype(rhs)>(rhs));
246 | 		}
247 | 	}
248 | };
249 | 
250 | template <typename Lhs, typename Rhs> struct compare: node<std::compare_three_way, Lhs, Rhs> { };
251 | template <typename Lhs, typename Rhs> struct less: node<relational<std::is_lt>, Lhs, Rhs> { };
252 | template <typename Lhs, typename Rhs> struct less_equal: node<relational<std::is_lteq>, Lhs, Rhs> { };
253 | template <typename Lhs, typename Rhs> struct equal: node<relational<std::is_eq>, Lhs, Rhs> { };
254 | template <typename Lhs, typename Rhs> struct not_equal: node<relational<std::is_neq>, Lhs, Rhs> { };
255 | template <typename Lhs, typename Rhs> struct greater: node<relational<std::is_gt>, Lhs, Rhs> { };
256 | template <typename Lhs, typename Rhs> struct greater_equal: node<relational<std::is_gteq>, Lhs, Rhs> { };
257 | 
258 | constexpr auto operator<=>(auto && lhs, auto && rhs) { return exact_build<compare>(lhs, rhs); }
259 | constexpr auto operator<(auto && lhs, auto && rhs) { return exact_build<less>(lhs, rhs); }
260 | constexpr auto operator<=(auto && lhs, auto && rhs) { return exact_build<less_equal>(lhs, rhs); }
261 | constexpr auto operator==(auto && lhs, auto && rhs) { return exact_build<equal>(lhs, rhs); }
262 | constexpr auto operator!=(auto && lhs, auto && rhs) { return exact_build<not_equal>(lhs, rhs); }
263 | constexpr auto operator>(auto && lhs, auto && rhs) { return exact_build<greater>(lhs, rhs); }
264 | constexpr auto operator>=(auto && lhs, auto && rhs) { return exact_build<greater_equal>(lhs, rhs); }
265 | 
266 | // basic math operators
267 | template <typename...> struct plus;
268 | 
269 | struct unary_plus_op {
270 | 	constexpr decltype(auto) operator()(auto && v) const {
271 | 		return +std::forward<decltype(v)>(v);
272 | 	}
273 | };
274 | 
275 | template <typename Lhs, typename Rhs> struct plus<Lhs, Rhs>: node<std::plus<>, Lhs, Rhs> { };
276 | template <typename Lhs, typename Rhs> struct minus: node<std::minus<>, Lhs, Rhs> { };
277 | template <typename Lhs, typename Rhs> struct multiplies: node<std::multiplies<>, Lhs, Rhs> { };
278 | template <typename Lhs, typename Rhs> struct divides: node<std::divides<>, Lhs, Rhs> { };
279 | template <typename Lhs, typename Rhs> struct modulus: node<std::modulus<>, Lhs, Rhs> { };
280 | template <typename T> struct negate: node<std::negate<>, T> { };
281 | template <typename T> struct plus<T>: node<unary_plus_op, T> { };
282 | 
283 | constexpr auto operator+(auto && lhs, auto && rhs) { return exact_build<plus>(lhs, rhs); }
284 | constexpr auto operator-(auto && lhs, auto && rhs) { return exact_build<minus>(lhs, rhs); }
285 | constexpr auto operator*(auto && lhs, auto && rhs) { return exact_build<multiplies>(lhs, rhs); }
286 | constexpr auto operator/(auto && lhs, auto && rhs) { return exact_build<divides>(lhs, rhs); }
287 | constexpr auto operator%(auto && lhs, auto && rhs) { return exact_build<modulus>(lhs, rhs); }
288 | constexpr auto operator-(auto && v) { return exact_build<negate>(v); }
289 | constexpr auto operator+(auto && v) { return exact_build<plus>(v); }
290 | 
291 | struct index_access {
292 | 	constexpr decltype(auto) operator()(auto &&... args) const {
293 | 		return false;
294 | 	}
295 | };
296 | 
297 | // constexpr auto operator[](auto && ... args) { return exact_build<index_access>(std::forward<Args>(args)...); }
298 | 
299 | } // namespace shorty
300 | 
301 | namespace placeholders {
302 | template <unsigned N> constexpr auto $arg = shorty::nth_argument<N>{};
303 | constexpr auto $args = shorty::pack_arguments{};
304 | constexpr auto $argc = shorty::argument_count{};
305 | 
306 | // nth-argument
307 | constexpr auto $0 = $arg<0>;
308 | constexpr auto $1 = $arg<1>;
309 | constexpr auto $2 = $arg<2>;
310 | constexpr auto $3 = $arg<3>;
311 | constexpr auto $4 = $arg<4>;
312 | constexpr auto $5 = $arg<5>;
313 | constexpr auto $6 = $arg<6>;
314 | constexpr auto $7 = $arg<7>;
315 | constexpr auto $8 = $arg<8>;
316 | constexpr auto $9 = $arg<9>;
317 | 
318 | // for niceness
319 | constexpr auto $it = shorty::nth_argument_with_query<0, []<typename T> { return std::input_or_output_iterator<T>; }>{};
320 | 
321 | constexpr auto $i = shorty::nth_argument_of_k<0, 1>{};
322 | constexpr auto $n = shorty::nth_argument_of_k<0, 1>{};
323 | constexpr auto $k = shorty::nth_argument_of_k<0, 1>{};
324 | 
325 | constexpr auto $lhs = shorty::nth_argument_of_k<0, 2>{};
326 | constexpr auto $rhs = shorty::nth_argument_of_k<1, 2>{};
327 | 
328 | constexpr auto $x = shorty::nth_argument_of_k<0, 3>{};
329 | constexpr auto $y = shorty::nth_argument_of_k<1, 3>{};
330 | constexpr auto $z = shorty::nth_argument_of_k<2, 3>{};
331 | 
332 | constexpr auto $a = shorty::nth_argument_of_k<0, 3>{};
333 | constexpr auto $b = shorty::nth_argument_of_k<1, 3>{};
334 | constexpr auto $c = shorty::nth_argument_of_k<2, 3>{};
335 | 
336 | // reference to external variable
337 | template <typename T> constexpr auto $(T & ref) {
338 | 	return shorty::reference<T>(ref);
339 | }
340 | 
341 | template <typename T> constexpr auto $(const T & ref) {
342 | 	return shorty::reference<const T>(ref);
343 | }
344 | 
345 | // apply function on result
346 | template <auto CustomOp> constexpr auto $(auto &&... args) {
347 | 	return shorty::apply<CustomOp>(std::forward<decltype(args)>(args)...);
348 | }
349 | 
350 | // cast to type
351 | template <typename T> constexpr auto $(auto &&... args) {
352 | 	return shorty::cast<T>(std::forward<decltype(args)>(args)...);
353 | }
354 | 
355 | // compile time known constant
356 | template <auto V> constexpr auto $const = shorty::constant<V>{};
357 | } // namespace placeholders
358 | 
359 | #include <algorithm>
360 | #include <array>
361 | #include <format>
362 | #include <iostream>
363 | #include <print>
364 | #include <span>
365 | 
366 | template <typename...> struct identify;
367 | 
368 | inline namespace here {
369 | 
370 | using namespace placeholders;
371 | 
372 | void sort(std::span<int> subject) {
373 | 	std::ranges::sort(subject, $lhs < $rhs);
374 | }
375 | 
376 | void transform_insitu(std::ranges::range auto && subject, auto && cb) {
377 | 	std::ranges::transform(subject, subject.begin(), cb);
378 | }
379 | 
380 | void transform(std::span<int> subject, float & coefficient) {
381 | 	transform_insitu(subject, $<int>($0 * $(coefficient)));
382 | }
383 | 
384 | template <size_t N> struct size;
385 | 
386 | bool contains(std::span<const std::string> dic) {
387 | 	auto f = $0 > "hana";
388 | 	// identify<decltype(f)> i;
389 | 	// identify<decltype(f)> i;
390 | 	return std::ranges::find_if(dic, f) != dic.end();
391 | }
392 | 
393 | } // namespace here
394 | 
395 | #include <cmath>
396 | 
397 | float pythagorus(float a, float b) {
398 | 	constexpr auto sqrt = [](std::floating_point auto val) { return std::sqrt(val); };
399 | 	constexpr auto f = $<sqrt>(($0 * $0) + ($1 * $1));
400 | 	return f(a, b);
401 | }
402 | 
403 | #ifdef EXECUTE
404 | 
405 | int main() {
406 | 	auto arr = std::array{1, 1, 2, 2, 3};
407 | 	float coefficient = 1.33;
408 | 	transform(arr, coefficient);
409 | 	sort(arr);
410 | 	for (int v: arr) {
411 | 		std::println("{}", v);
412 | 	}
413 | 
414 | 	constexpr auto sum = [](auto... v) { return (v + ...); };
415 | 
416 | 	auto avg_window = arr | std::views::transform($0 * 5);
417 | 
418 | 	std::println("sliding average:");
419 | 	for (auto v: avg_window) {
420 | 		std::println("{}", v);
421 | 	}
422 | 
423 | 	using namespace std::string_literals;
424 | 	auto arr2 = std::array{"anna"s, "beata"s, "jana"s};
425 | 	if (contains(arr2)) {
426 | 		std::println("something after hana");
427 | 	}
428 | }
429 | #endif


--------------------------------------------------------------------------------
/single-header/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_custom_target(single-header DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shorty.hpp)
 2 | 
 3 | message(STATUS "${SHORTY_HEADERS}")
 4 | 
 5 | add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/shorty.hpp COMMAND ${CMAKE_COMMAND} 	-DINPUT=${CMAKE_SOURCE_DIR}/source/shorty/shorty.hpp
 6 | 	-DTEMPORARY=${CMAKE_CURRENT_BINARY_DIR}/tmp.hpp
 7 | 	-DTEMPLATE=${CMAKE_CURRENT_SOURCE_DIR}/shorty.hpp.in
 8 | 	-DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/shorty.hpp 
 9 | 	-DINCLUDE_DIRECTORY=${CMAKE_SOURCE_DIR}/source/shorty
10 | 	-P ${CMAKE_CURRENT_SOURCE_DIR}/generate.cmake
11 | 	DEPENDS 
12 | 	${CMAKE_CURRENT_SOURCE_DIR}/generate.cmake
13 | 	${SHORTY_HEADERS}
14 | )
15 | 
16 | add_library(shorty-single-header INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/shorty.hpp)
17 | add_dependencies(shorty-single-header single-header)
18 | target_compile_features(shorty-single-header INTERFACE cxx_std_26)
19 | target_include_directories(shorty-single-header INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})


--------------------------------------------------------------------------------
/single-header/generate.cmake:
--------------------------------------------------------------------------------
 1 | message(STATUS "Generating shorty.hpp")
 2 | 
 3 | # use QUOM to create basic single header
 4 | set(COMMAND python3 -m quom ${INPUT} tmp.hpp --include_guard "SHORTY_SHORTY_.*" --include_directory ${INCLUDE_DIRECTORY} --trim)
 5 | 
 6 | execute_process(COMMAND ${COMMAND} ERROR_VARIABLE ERRORS OUTPUT_VARIABLE OUTPUTS RESULT_VARIABLE RESULT_VAR)
 7 | 
 8 | file (READ tmp.hpp CONTENT_TMP)
 9 | 
10 | string(REGEX REPLACE "[^\n]*SHORTY_IS_IN_MODULE" "" CONTENT_TMP2 "${CONTENT_TMP}")
11 | string(REGEX REPLACE "#define SHORTY_EXPORT[^\n]*\n" "" CONTENT_TMP3 "${CONTENT_TMP2}")
12 | string(REGEX REPLACE "SHORTY_EXPORT *" "" CONTENT_TMP4 "${CONTENT_TMP3}")
13 | 
14 | #message(STATUS "${CONTENT_TMP4}")
15 | 
16 | set(CONTENT_OF_SINGLE_HEADER "${CONTENT_TMP4}")
17 | 
18 | configure_file(${TEMPLATE} ${OUTPUT} @ONLY)
19 | 
20 | execute_process(COMMAND clang-format -i ${OUTPUT} RESULT_VARIABLE RESULT_VAR)
21 | 
22 | #message(STATUS "clang-format = ${RESULT_VAR}")
23 | 
24 | 


--------------------------------------------------------------------------------
/single-header/shorty.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SHORTY_HPP
  2 | #define SHORTY_HPP
  3 | 
  4 | #include <array>
  5 | #include <ranges>
  6 | #include <tuple>
  7 | #include <complex>
  8 | 
  9 | namespace shorty {
 10 | 
 11 | template <typename> constexpr bool is_tuple_like = false;
 12 | template <typename T, std::size_t Extent> constexpr bool is_tuple_like<std::array<T, Extent>> = true;
 13 | template <typename... Ts> constexpr bool is_tuple_like<std::tuple<Ts...>> = true;
 14 | template <typename A, typename B> constexpr bool is_tuple_like<std::pair<A, B>> = true;
 15 | template <typename T> constexpr bool is_tuple_like<std::complex<T>> = true;
 16 | // TODO subrange
 17 | 
 18 | template <typename T> concept tuple_like = is_tuple_like<std::remove_cvref_t<T>>;
 19 | 
 20 | } // namespace shorty
 21 | 
 22 | #include <utility>
 23 | 
 24 | namespace shorty {
 25 | // groups
 26 | struct default_group {
 27 | 	// no parameter
 28 | };
 29 | struct binary_ops {
 30 | 	static constexpr std::size_t arity = 2;
 31 | };
 32 | struct unary_ops {
 33 | 	static constexpr std::size_t arity = 1;
 34 | };
 35 | template <std::size_t Arity, auto> struct group {
 36 | 	static constexpr std::size_t arity = Arity;
 37 | };
 38 | struct xyz {
 39 | };
 40 | struct abc {
 41 | };
 42 | struct ink {
 43 | };
 44 | 
 45 | } // namespace shorty
 46 | 
 47 | namespace shorty::ops {
 48 | 
 49 | // ops
 50 | struct compare {
 51 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) <=> std::forward<decltype(rhs)>(rhs))) {
 52 | 		return std::forward<decltype(lhs)>(lhs) <=> std::forward<decltype(rhs)>(rhs);
 53 | 	}
 54 | };
 55 | struct less {
 56 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) < std::forward<decltype(rhs)>(rhs))) {
 57 | 		return std::forward<decltype(lhs)>(lhs) < std::forward<decltype(rhs)>(rhs);
 58 | 	}
 59 | };
 60 | struct less_equal {
 61 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) <= std::forward<decltype(rhs)>(rhs))) {
 62 | 		return std::forward<decltype(lhs)>(lhs) <= std::forward<decltype(rhs)>(rhs);
 63 | 	}
 64 | };
 65 | struct equal {
 66 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) == std::forward<decltype(rhs)>(rhs))) {
 67 | 		return std::forward<decltype(lhs)>(lhs) == std::forward<decltype(rhs)>(rhs);
 68 | 	}
 69 | };
 70 | struct not_equal {
 71 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) != std::forward<decltype(rhs)>(rhs))) {
 72 | 		return std::forward<decltype(lhs)>(lhs) != std::forward<decltype(rhs)>(rhs);
 73 | 	}
 74 | };
 75 | struct greater_equal {
 76 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) >= std::forward<decltype(rhs)>(rhs))) {
 77 | 		return std::forward<decltype(lhs)>(lhs) >= std::forward<decltype(rhs)>(rhs);
 78 | 	}
 79 | };
 80 | struct greater {
 81 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) > std::forward<decltype(rhs)>(rhs))) {
 82 | 		return std::forward<decltype(lhs)>(lhs) > std::forward<decltype(rhs)>(rhs);
 83 | 	}
 84 | };
 85 | struct unary_plus {
 86 | 	static constexpr auto operator()(auto && val) noexcept(noexcept(+std::forward<decltype(val)>(val))) {
 87 | 		return +std::forward<decltype(val)>(val);
 88 | 	}
 89 | };
 90 | struct unary_minus {
 91 | 	static constexpr auto operator()(auto && val) noexcept(noexcept(-std::forward<decltype(val)>(val))) {
 92 | 		return -std::forward<decltype(val)>(val);
 93 | 	}
 94 | };
 95 | template <typename Op = void> struct assign;
 96 | template <typename Op> struct assign {
 97 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) = Op{}(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs)))) {
 98 | 		return lhs = Op{}(lhs, rhs);
 99 | 	}
100 | };
101 | 
102 | template <> struct assign<void> {
103 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) = std::forward<decltype(rhs)>(rhs))) {
104 | 		return std::forward<decltype(lhs)>(lhs) = std::forward<decltype(rhs)>(rhs);
105 | 	}
106 | };
107 | 
108 | struct tuplize {
109 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::make_tuple(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs)))) {
110 | 		return std::make_tuple(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs));
111 | 	}
112 | 	static constexpr auto operator()(tuple_like auto && lhs, auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
113 | 		return std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs)));
114 | 	}
115 | 	static constexpr auto operator()(auto && lhs, tuple_like auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
116 | 		return std::tuple_cat(std::make_tuple(std::forward<decltype(lhs)>(lhs)), std::forward<decltype(rhs)>(rhs));
117 | 	}
118 | 	static constexpr auto operator()(tuple_like auto && lhs, tuple_like auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
119 | 		return std::tuple_cat(std::make_tuple(std::forward<decltype(lhs)>(lhs)), std::make_tuple(std::forward<decltype(rhs)>(rhs)));
120 | 	}
121 | };
122 | 
123 | template <typename...> struct identify;
124 | 
125 | struct index {
126 | #pragma clang diagnostic push
127 | #pragma clang diagnostic ignored "-Wsign-conversion"
128 | 	static constexpr auto operator()(auto && subject, auto &&... args) noexcept(noexcept(std::forward<decltype(subject)>(subject)[std::forward<decltype(args)>(args)...])) {
129 | 		return std::forward<decltype(subject)>(subject)[std::forward<decltype(args)>(args)...];
130 | 	}
131 | #pragma clang diagnostic pop
132 | };
133 | 
134 | template <typename T> struct cast {
135 | 	static constexpr auto operator()(auto && arg) noexcept(noexcept(static_cast<T>(std::forward<decltype(arg)>(arg)))) {
136 | 		return static_cast<T>(std::forward<decltype(arg)>(arg));
137 | 	}
138 | };
139 | 
140 | template <auto Op> struct call {
141 | 	static constexpr auto operator()(auto &&... args) noexcept(noexcept(Op(std::forward<decltype(args)>(args)...))) {
142 | 		return Op(std::forward<decltype(args)>(args)...);
143 | 	}
144 | 	//
145 | 	// static constexpr auto operator()(tuple_like auto & arg) noexcept(noexcept(Op(std::forward<decltype(args)>(args)...))) {
146 | 	//	return Op(std::forward<decltype(args)>(args)...);
147 | 	//}
148 | };
149 | 
150 | template <typename Op> struct callable {
151 | 	static constexpr auto operator()(auto &&... args) noexcept(noexcept(Op{}(std::forward<decltype(args)>(args)...))) {
152 | 		return Op{}(std::forward<decltype(args)>(args)...);
153 | 	}
154 | 	// unwrap tuple for us
155 | 	static constexpr auto operator()(tuple_like auto && tuple_arg) noexcept(noexcept(std::apply(callable::operator(), std::forward<decltype(tuple_arg)>(tuple_arg)))) {
156 | 		return std::apply(callable::operator(), std::forward<decltype(tuple_arg)>(tuple_arg));
157 | 	}
158 | };
159 | 
160 | } // namespace shorty::ops
161 | 
162 | #include <utility>
163 | 
164 | namespace shorty {
165 | 
166 | #if __cpp_pack_indexing >= 202311L
167 | template <typename... Ts> using first = Ts...[0];
168 | template <typename... Ts> constexpr auto first_thing(Ts &&... args) {
169 | 	return args...[0];
170 | }
171 | 
172 | #else
173 | 
174 | template <typename...> struct head_helper;
175 | template <typename Head, typename... Ts> struct head_helper<Head, Ts...> {
176 | 	using result = Head;
177 | };
178 | template <typename Head, typename... Ts> constexpr auto first_thing(Head && head, Ts &&...) {
179 | 	return head;
180 | }
181 | 
182 | template <typename... Ts> using first = head_helper<Ts...>::result;
183 | 
184 | template <size_t N, typename First, typename... Args> constexpr auto extract_nth(First && first, Args &&... args) noexcept {
185 | 	if constexpr (N == 0u) {
186 | 		return first;
187 | 	} else {
188 | 		return extract_nth<N - 1u>(std::forward<Args>(args)...);
189 | 	}
190 | }
191 | 
192 | #endif
193 | 
194 | } // namespace shorty
195 | 
196 | #include <optional>
197 | #include <tuple>
198 | #include <type_traits>
199 | #include <utility>
200 | #include <concepts>
201 | 
202 | namespace shorty {
203 | 
204 | template <typename...> struct identify;
205 | template <auto...> struct identify_value;
206 | 
207 | template <typename Op, typename... Operands> struct node;
208 | 
209 | template <typename T> using select = std::remove_cvref_t<T>;
210 | 
211 | template <typename T>
212 | concept knows_minimal_argument_count = requires {
213 | 	requires std::same_as<std::remove_cvref_t<decltype(T::argc_at_least)>, std::size_t>;
214 | };
215 | 
216 | template <typename T> concept can_calculate_exact_argument_count = requires {
217 | 	{ T::arg_info.consistent } -> std::convertible_to<bool>;
218 | };
219 | 
220 | template <typename T> concept has_group_type = requires {
221 | 	typename std::remove_cvref_t<T>::group;
222 | };
223 | 
224 | struct ast_node;
225 | 
226 | #if __cpp_constexpr_exceptions >= 202411L
227 | struct shorty_constraint_failure {
228 | 	const char * msg;
229 | 
230 | 	static consteval auto inconsistent() noexcept {
231 | 		return shorty_constraint_failure{"inconsistent number of required arguments"};
232 | 	}
233 | 
234 | 	static consteval auto not_enough() noexcept {
235 | 		return shorty_constraint_failure{"not enough arguments provided (expected more)"};
236 | 	}
237 | 
238 | 	static consteval auto too_much() noexcept {
239 | 		return shorty_constraint_failure{"more arguments provided than needed"};
240 | 	}
241 | 
242 | 	constexpr const char * what() const {
243 | 		return msg;
244 | 	}
245 | };
246 | #endif
247 | 
248 | struct incosistent_groups {
249 | 	static constexpr bool consistent = false;
250 | };
251 | 
252 | struct neutral_info {
253 | 	static constexpr bool consistent = true;
254 | 
255 | 	consteval friend neutral_info operator+(neutral_info, neutral_info) noexcept {
256 | 		return {};
257 | 	}
258 | };
259 | 
260 | consteval incosistent_groups operator+(incosistent_groups, incosistent_groups) noexcept {
261 | 	return {};
262 | }
263 | 
264 | template <typename Group> struct argument_info {
265 | 	std::size_t min = 0;
266 | 	static constexpr std::size_t exact = 0;
267 | 	static constexpr bool consistent = true;
268 | 
269 | 	consteval operator incosistent_groups() const noexcept {
270 | 		return {};
271 | 	}
272 | 
273 | 	consteval friend argument_info operator+(const argument_info & lhs, const argument_info & rhs) noexcept {
274 | 		return argument_info{
275 | 			.min = std::max(lhs.min, rhs.min),
276 | 		};
277 | 	}
278 | 
279 | 	consteval friend argument_info operator+(neutral_info, const argument_info & rhs) noexcept {
280 | 		return rhs;
281 | 	}
282 | 
283 | 	consteval friend argument_info operator+(const argument_info & lhs, neutral_info) noexcept {
284 | 		return lhs;
285 | 	}
286 | 
287 | 	static consteval std::size_t exact_or(std::size_t provided) noexcept {
288 | 		return exact == std::dynamic_extent ? provided : exact;
289 | 	}
290 | 
291 | 	template <typename T> static consteval argument_info from() noexcept {
292 | 		if constexpr (knows_minimal_argument_count<T>) {
293 | 			return {.min = std::remove_cvref_t<T>::argc_at_least};
294 | 		} else {
295 | 			return {};
296 | 		}
297 | 	}
298 | };
299 | 
300 | template <typename T> static constexpr auto argument_info_about = [] {
301 | 	if constexpr (can_calculate_exact_argument_count<T>) {
302 | 		return T::arg_info;
303 | 	} else if constexpr (has_group_type<T>) {
304 | 		return argument_info<typename T::group>::template from<T>();
305 | 	} else if constexpr (knows_minimal_argument_count<T>) {
306 | 		return argument_info<default_group>{.min = std::remove_cvref_t<T>::argc_at_least};
307 | 	} else if constexpr (std::convertible_to<ast_node, T>) {
308 | 		return neutral_info{};
309 | 	} else {
310 | 		return neutral_info{};
311 | 	}
312 | }();
313 | 
314 | consteval bool validate_minimal_number_of_arguments(std::size_t provided, std::size_t expected) {
315 | 	if (expected > provided) {
316 | #if __cpp_constexpr_exceptions >= 202411L
317 | 		throw shorty_constraint_failure::not_enough();
318 | #else
319 | 		return false;
320 | #endif
321 | 	} else {
322 | 		return true;
323 | 	}
324 | }
325 | 
326 | consteval bool validate_exact_number_of_arguments(std::size_t provided, std::size_t expected) {
327 | 	if (expected != std::dynamic_extent && expected != provided) {
328 | #if __cpp_constexpr_exceptions >= 202411L
329 | 		throw shorty_constraint_failure::too_much();
330 | #else
331 | 		return false;
332 | #endif
333 | 	} else {
334 | 		return true;
335 | 	}
336 | }
337 | 
338 | template <typename... Args> consteval std::size_t gather_number_of_arguments() {
339 | 	if constexpr (sizeof...(Args) == 1 && tuple_like<first<Args...>>) {
340 | 		const std::size_t count = std::tuple_size_v<std::remove_cvref_t<first<Args...>>>;
341 | 		return count;
342 | 	} else {
343 | 		return sizeof...(Args);
344 | 	}
345 | }
346 | 
347 | // basic ast_node which is used for ADL lookup of operators
348 | struct ast_node {
349 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator<(Lhs && lhs, Rhs && rhs) {
350 | 		return node<ops::less, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
351 | 	}
352 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator<=(Lhs && lhs, Rhs && rhs) {
353 | 		return node<ops::less_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
354 | 	}
355 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator==(Lhs && lhs, Rhs && rhs) {
356 | 		return node<ops::equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
357 | 	}
358 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator!=(Lhs && lhs, Rhs && rhs) {
359 | 		return node<ops::not_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
360 | 	}
361 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator>=(Lhs && lhs, Rhs && rhs) {
362 | 		return node<ops::greater_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
363 | 	}
364 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator>(Lhs && lhs, Rhs && rhs) {
365 | 		return node<ops::greater, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
366 | 	}
367 | 
368 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator+(Lhs && lhs, Rhs && rhs) {
369 | 		return node<std::plus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
370 | 	}
371 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator-(Lhs && lhs, Rhs && rhs) {
372 | 		return node<std::minus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
373 | 	}
374 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator*(Lhs && lhs, Rhs && rhs) {
375 | 		return node<std::multiplies<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
376 | 	}
377 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator/(Lhs && lhs, Rhs && rhs) {
378 | 		return node<std::divides<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
379 | 	}
380 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator%(Lhs && lhs, Rhs && rhs) {
381 | 		return node<std::modulus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
382 | 	}
383 | 
384 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator+=(Lhs && lhs, Rhs && rhs) {
385 | 		return node<ops::assign<std::plus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
386 | 	}
387 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator-=(Lhs && lhs, Rhs && rhs) {
388 | 		return node<ops::assign<std::minus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
389 | 	}
390 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator*=(Lhs && lhs, Rhs && rhs) {
391 | 		return node<ops::assign<std::multiplies<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
392 | 	}
393 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator/=(Lhs && lhs, Rhs && rhs) {
394 | 		return node<ops::assign<std::divides<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
395 | 	}
396 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator%=(Lhs && lhs, Rhs && rhs) {
397 | 		return node<ops::assign<std::modulus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
398 | 	}
399 | 	template <typename Self, typename Rhs> constexpr auto operator=(this Self && self, Rhs && rhs) {
400 | 		return node<ops::assign<void>, select<Self>, select<Rhs>>{std::forward<Self>(self), std::forward<Rhs>(rhs)};
401 | 	}
402 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator,(Lhs && lhs, Rhs && rhs) {
403 | 		return node<ops::tuplize, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
404 | 	}
405 | 
406 | 	template <typename Self> constexpr auto operator+(this Self && self) {
407 | 		return node<ops::unary_plus, select<Self>>{std::forward<Self>(self)};
408 | 	}
409 | 	template <typename Self> constexpr auto operator-(this Self && self) {
410 | 		return node<ops::unary_minus, select<Self>>{std::forward<Self>(self)};
411 | 	}
412 | 	template <typename Self, typename... Args> constexpr auto operator[](this Self && self, Args &&... args) {
413 | 		return node<ops::index, select<Self>, select<Args>...>{std::forward<Self>(self), std::forward<Args>(args)...};
414 | 	}
415 | 
416 | 	template <typename Self> static constexpr auto call_info = argument_info_about<std::remove_cvref_t<Self>>;
417 | 	template <typename... Args> static constexpr auto number_of_arguments = gather_number_of_arguments<Args...>();
418 | 
419 | 	// this is only called outside
420 | 	// this gymnastics is also to improve error message
421 | 	template <typename Self, typename... Args, auto argn = number_of_arguments<Args...>, auto min_argn_expected = call_info<Self>.min>
422 | 	[[nodiscard, gnu::flatten, gnu::always_inline]]
423 | 	constexpr auto operator() // calling shorty
424 | 		(this Self && self, Args &&... args) requires(validate_minimal_number_of_arguments(argn, min_argn_expected))
425 | 	{
426 | 		if constexpr (sizeof...(Args) == 1 && tuple_like<first<Args...>>) {
427 | 			auto && first_arg = first_thing(std::forward<Args>(args)...);
428 | #if __cpp_structured_bindings >= 202411L
429 | 			auto && [... subargs] = first_arg;
430 | 			return std::forward<Self>(self).operator()(std::forward<decltype(subargs)>(subargs)...);
431 | #else
432 | 			return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
433 | 				return std::forward<Self>(self).operator()(std::get<Idx>(first_arg)...);
434 | 			}(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<decltype(first_arg)>>>());
435 | #endif
436 | 		} else {
437 | 			return self.eval(std::forward<Args>(args)...);
438 | 		}
439 | 	}
440 | };
441 | 
442 | template <typename T, typename... Args> constexpr decltype(auto) evaluate(T && obj, [[maybe_unused]] Args &&... args) {
443 | 	if constexpr (requires { obj.eval(std::forward<Args>(args)...); }) {
444 | 		return obj.eval(std::forward<Args>(args)...);
445 | 	} else {
446 | 		return obj;
447 | 	}
448 | }
449 | 
450 | template <typename Op, typename... Operands> struct node: ast_node {
451 | 	static constexpr auto arg_info = (argument_info_about<std::remove_cvref_t<Operands>> + ... + neutral_info{});
452 | 	static constexpr bool consistent = arg_info.consistent;
453 | 	static_assert(consistent, "expected number of arguments is not consistent (hint: mixing something like $lhs and $x?)");
454 | 	using base_node = node;
455 | 
456 | 	static constexpr auto op = Op{};
457 | 	[[no_unique_address]] std::tuple<Operands...> ast_operands;
458 | 
459 | 	node(node &&) = default;
460 | 	node(const node &) = default;
461 | 	constexpr node(std::convertible_to<Operands> auto &&... _ast_operands): ast_operands{std::forward<decltype(_ast_operands)>(_ast_operands)...} { }
462 | 
463 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
464 | #if __cpp_structured_bindings >= 202411L
465 | 		auto && [... operands] = ast_operands;
466 | 		return op(evaluate(std::forward<decltype(operands)>(operands), std::forward<Args>(args)...)...);
467 | #else
468 | 		return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
469 | 			return op(evaluate(std::get<Idx>(ast_operands), std::forward<Args>(args)...)...);
470 | 		}(std::make_index_sequence<std::tuple_size<decltype(ast_operands)>::value>());
471 | #endif
472 | 	}
473 | };
474 | 
475 | // this will return Nth argument from the shorty's lambda
476 | template <unsigned N> struct nth_argument: ast_node {
477 | 	static constexpr std::size_t argc_at_least = N + 1;
478 | 	using group = default_group;
479 | 
480 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
481 | 		static_assert(N < sizeof...(Args));
482 | #if __cpp_pack_indexing >= 202311L
483 | 		return args...[N];
484 | #else
485 | 		return extract_nth<N>(std::forward<Args>(args)...);
486 | #endif
487 | 	}
488 | };
489 | 
490 | template <unsigned N, typename Group = void> struct nth_argument_with_group: ast_node {
491 | 	static constexpr std::size_t argc_at_least = N + 1;
492 | 	using group = Group;
493 | 
494 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
495 | 		if constexpr (requires { Group::arity; }) {
496 | 			static_assert(Group::arity == sizeof...(Args));
497 | 		}
498 | 
499 | 		static_assert(N < sizeof...(Args));
500 | #if __cpp_pack_indexing >= 202311L
501 | 		return args...[N];
502 | #else
503 | 		return extract_nth<N>(std::forward<Args>(args)...);
504 | #endif
505 | 	}
506 | };
507 | 
508 | // same as `nth-argument` but `Query` callable must return true for argument of `std::type_identity<T>`
509 | template <unsigned N, auto Query> struct nth_argument_with_query: ast_node {
510 | 	static constexpr std::size_t argc_at_least = N + 1;
511 | 
512 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
513 | 		static_assert(N < sizeof...(Args));
514 | #if __cpp_pack_indexing >= 202311L
515 | 		static_assert(Query(std::type_identity<Args... [N]>{}));
516 | 		return args...[N];
517 | #else
518 | 		static_assert(Query(std::type_identity<decltype(extract_nth<N>(std::forward<Args>(args)...))>{}));
519 | 		return extract_nth<N>(std::forward<Args>(args)...);
520 | #endif
521 | 	}
522 | };
523 | 
524 | // number of arguments provided to shorty's lambda
525 | struct argument_count: ast_node {
526 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
527 | 		return sizeof...(Args);
528 | 	}
529 | };
530 | 
531 | // wrap all provided arguments to shorty's lambda and return a tuple
532 | struct pack_arguments: ast_node {
533 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
534 | 		return std::tuple(std::forward<Args>(args)...);
535 | 	}
536 | };
537 | 
538 | // store CNTTP constant
539 | template <auto V> struct constant: ast_node {
540 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
541 | 		return V;
542 | 	}
543 | };
544 | 
545 | // store a value of any type
546 | template <typename T> struct value: ast_node {
547 | 	T data;
548 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
549 | 		return data;
550 | 	}
551 | };
552 | 
553 | // store a reference to a string literals
554 | template <typename CharT, std::size_t N> struct static_string: ast_node {
555 | 	using type = const CharT (&)[N];
556 | 	type data;
557 | 	consteval static_string(const CharT (&_data)[N]) noexcept: data{_data} { }
558 | 	template <typename... Args> constexpr type eval(Args &&...) const {
559 | 		return data;
560 | 	}
561 | };
562 | 
563 | // external const/non-const reference
564 | template <typename T> struct reference: ast_node {
565 | 	T & value;
566 | 	constexpr reference(T & _value) noexcept: value{_value} { }
567 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
568 | 		return value;
569 | 	}
570 | };
571 | 
572 | } // namespace shorty
573 | 
574 | namespace shorty::literals {
575 | template <unsigned N> constexpr auto $arg = shorty::nth_argument<N>{};
576 | 
577 | constexpr auto $args = shorty::pack_arguments{};
578 | constexpr auto $argc = shorty::argument_count{};
579 | // constexpr auto $unused = shorty::argument_unused{}; all unused arguments will wrap into a tuple
580 | 
581 | // nth-argument
582 | constexpr auto $0 = $arg<0>;
583 | constexpr auto $1 = $arg<1>;
584 | constexpr auto $2 = $arg<2>;
585 | constexpr auto $3 = $arg<3>;
586 | constexpr auto $4 = $arg<4>;
587 | constexpr auto $5 = $arg<5>;
588 | constexpr auto $6 = $arg<6>;
589 | constexpr auto $7 = $arg<7>;
590 | constexpr auto $8 = $arg<8>;
591 | constexpr auto $9 = $arg<9>;
592 | 
593 | // #if __cpp_template_parameters >= 202502L
594 | //	template <template <typename> concept C> constexpr auto @0 = $arg<0>;
595 | //	template <template <typename> concept C> constexpr auto @1 = $arg<1>;
596 | //	template <template <typename> concept C> constexpr auto @2 = $arg<2>;
597 | //	template <template <typename> concept C> constexpr auto @3 = $arg<3>;
598 | //	template <template <typename> concept C> constexpr auto @4 = $arg<4>;
599 | //	template <template <typename> concept C> constexpr auto @5 = $arg<5>;
600 | //	template <template <typename> concept C> constexpr auto @6 = $arg<6>;
601 | //	template <template <typename> concept C> constexpr auto @7 = $arg<7>;
602 | //	template <template <typename> concept C> constexpr auto @8 = $arg<8>;
603 | //	template <template <typename> concept C> constexpr auto @9 = $arg<9>;
604 | // #endif
605 | 
606 | // for niceness
607 | constexpr auto $it = shorty::nth_argument_with_query<0, []<typename T> { return std::input_or_output_iterator<T>; }>{};
608 | 
609 | constexpr auto $i = shorty::nth_argument_with_group<0, shorty::group<1, 'i'>>{};
610 | constexpr auto $n = shorty::nth_argument_with_group<0, shorty::group<1, 'n'>>{};
611 | constexpr auto $k = shorty::nth_argument_with_group<0, shorty::group<1, 'k'>>{};
612 | 
613 | constexpr auto $lhs = shorty::nth_argument_with_group<0, shorty::binary_ops>{};
614 | constexpr auto $rhs = shorty::nth_argument_with_group<1, shorty::binary_ops>{};
615 | 
616 | constexpr auto $in = shorty::nth_argument_with_group<0, shorty::unary_ops>{};
617 | 
618 | constexpr auto $x = shorty::nth_argument_with_group<0, shorty::xyz>{};
619 | constexpr auto $y = shorty::nth_argument_with_group<1, shorty::xyz>{};
620 | constexpr auto $z = shorty::nth_argument_with_group<2, shorty::xyz>{};
621 | 
622 | constexpr auto $a = shorty::nth_argument_with_group<0, shorty::abc>{};
623 | constexpr auto $b = shorty::nth_argument_with_group<1, shorty::abc>{};
624 | constexpr auto $c = shorty::nth_argument_with_group<2, shorty::abc>{};
625 | constexpr auto $d = shorty::nth_argument_with_group<3, shorty::abc>{};
626 | constexpr auto $e = shorty::nth_argument_with_group<4, shorty::abc>{};
627 | constexpr auto $f = shorty::nth_argument_with_group<5, shorty::abc>{};
628 | 
629 | // `$cast<T>(expr)` or `$<T>(expr)` are lazy static_cast
630 | template <typename T> constexpr auto $cast(auto && arg) {
631 | 	return node<ops::cast<T>, select<decltype(arg)>>{std::forward<decltype(arg)>(arg)};
632 | }
633 | template <typename T> constexpr auto $(auto && arg) {
634 | 	return node<ops::cast<T>, select<decltype(arg)>>{std::forward<decltype(arg)>(arg)};
635 | }
636 | 
637 | // `$<fnc>(args...)` or `$call<fnc>(args...)` are lazy function
638 | template <auto Op> constexpr auto $(auto &&... arg) {
639 | 	return node<ops::call<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
640 | }
641 | 
642 | template <auto Op> constexpr auto $call(auto &&... arg) {
643 | 	return node<ops::call<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
644 | }
645 | 
646 | template <typename T> concept callable = requires {
647 | 	T::operator();
648 | };
649 | 
650 | // `$<callable>(args...)` or `$call<callable>(args...)` are lazy function
651 | template <callable Op> constexpr auto $(auto &&... arg) {
652 | 	return node<ops::callable<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
653 | }
654 | template <typename Op> constexpr auto $call(auto &&... arg) {
655 | 	return node<ops::callable<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
656 | }
657 | 
658 | // `$value(VALUE)
659 | constexpr auto $value(auto && ref) noexcept {
660 | 	return shorty::value(std::forward<decltype(ref)>(ref));
661 | }
662 | constexpr auto $val(auto && ref) noexcept {
663 | 	return shorty::value(std::forward<decltype(ref)>(ref));
664 | }
665 | // `$(REF)` or `$(CREF)`
666 | constexpr auto $(auto & ref) noexcept {
667 | 	return shorty::reference<std::remove_reference_t<decltype(ref)>>(ref);
668 | }
669 | constexpr auto $(const auto & ref) noexcept {
670 | 	return shorty::reference<const std::remove_reference_t<decltype(ref)>>(ref);
671 | }
672 | constexpr auto $ref(auto & ref) noexcept {
673 | 	return shorty::reference<std::remove_reference_t<decltype(ref)>>(ref);
674 | }
675 | constexpr auto $ref(const auto & ref) noexcept {
676 | 	return shorty::reference<const std::remove_reference_t<decltype(ref)>>(ref);
677 | }
678 | // `$const<VALUE>` (CNTTP constant)
679 | template <auto V> constexpr auto $const = shorty::constant<V>{};
680 | template <auto V> constexpr auto $fixed = shorty::constant<V>{};
681 | } // namespace shorty::literals
682 | 
683 | template <typename...> struct identify;
684 | 
685 | namespace shorty {
686 | 
687 | }
688 | 
689 | #endif
690 | 


--------------------------------------------------------------------------------
/single-header/shorty.hpp.in:
--------------------------------------------------------------------------------
1 | #ifndef SHORTY_HPP
2 | #define SHORTY_HPP
3 | 
4 | @CONTENT_OF_SINGLE_HEADER@
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/source/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SHORTY_SOURCES shorty.cppm literals.cppm leaves.cppm ops.cppm compatibility/pack-indexing.cppm compatibility/concepts.cppm)
 2 | 
 3 | set(SHORTY_HEADERS ${SHORTY_SOURCES})
 4 | list(TRANSFORM SHORTY_HEADERS REPLACE "(.*)\.cppm$" "\\1.hpp")
 5 | 
 6 | list(TRANSFORM SHORTY_HEADERS PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/shorty/")
 7 | list(TRANSFORM SHORTY_SOURCES PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/shorty/")
 8 | 
 9 | 
10 | if(SHORTY_IS_IN_MODULE)
11 | 	add_library(shorty)
12 | 	target_sources(shorty PUBLIC FILE_SET modules TYPE CXX_MODULES FILES ${SHORTY_SOURCES})
13 | 	target_compile_features(shorty PUBLIC cxx_std_26)
14 | 	target_include_directories(shorty PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
15 | 	#set_target_properties(shorty PROPERTIES CXX_MODULE_STD ON)
16 | 	target_compile_definitions(shorty PUBLIC SHORTY_IS_IN_MODULE)
17 | else()
18 | 	add_library(shorty INTERFACE)
19 | 	target_sources(shorty INTERFACE FILE_SET headers TYPE HEADERS FILES ${SHORTY_HEADERS})
20 | 	target_compile_features(shorty INTERFACE cxx_std_26)
21 | 	target_include_directories(shorty INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
22 | endif()
23 | 
24 | set(SHORTY_HEADERS ${SHORTY_HEADERS} PARENT_SCOPE)


--------------------------------------------------------------------------------
/source/shorty/compatibility/concepts.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty:concepts;
 2 | 
 3 | import std;
 4 | 
 5 | #ifndef SHORTY_IS_IN_MODULE
 6 | #define SHORTY_IS_IN_MODULE
 7 | #endif
 8 | 
 9 | #include "concepts.hpp"
10 | 


--------------------------------------------------------------------------------
/source/shorty/compatibility/concepts.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SHORTY_SHORTY_COMPATIBILITY_CONCEPTS_HPP
 2 | #define SHORTY_SHORTY_COMPATIBILITY_CONCEPTS_HPP
 3 | 
 4 | #ifdef SHORTY_IS_IN_MODULE
 5 | #define SHORTY_EXPORT export
 6 | #else // SHORTY_IS_IN_MODULE
 7 | #include <array>
 8 | #include <ranges>
 9 | #include <tuple>
10 | #include <complex>
11 | #endif // SHORTY_IS_IN_MODULE
12 | 
13 | namespace shorty {
14 | 
15 | template <typename> constexpr bool is_tuple_like = false;
16 | template <typename T, std::size_t Extent> constexpr bool is_tuple_like<std::array<T, Extent>> = true;
17 | template <typename... Ts> constexpr bool is_tuple_like<std::tuple<Ts...>> = true;
18 | template <typename A, typename B> constexpr bool is_tuple_like<std::pair<A, B>> = true;
19 | template <typename T> constexpr bool is_tuple_like<std::complex<T>> = true;
20 | // TODO subrange
21 | 
22 | SHORTY_EXPORT template <typename T> concept tuple_like = is_tuple_like<std::remove_cvref_t<T>>;
23 | 
24 | } // namespace shorty
25 | 
26 | #endif // SHORTY_SHORTY_COMPATIBILITY_CONCEPTS_HPP
27 | 


--------------------------------------------------------------------------------
/source/shorty/compatibility/pack-indexing.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty:pack_indexing;
 2 | 
 3 | import std;
 4 | 
 5 | #ifndef SHORTY_IS_IN_MODULE
 6 | #define SHORTY_IS_IN_MODULE
 7 | #endif
 8 | 
 9 | #include "pack-indexing.hpp"
10 | 


--------------------------------------------------------------------------------
/source/shorty/compatibility/pack-indexing.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SHORTY_SHORTY_COMPATIBILITY_PACK_INDEXING_HPP
 2 | #define SHORTY_SHORTY_COMPATIBILITY_PACK_INDEXING_HPP
 3 | 
 4 | #ifdef SHORTY_IS_IN_MODULE
 5 | #define SHORTY_EXPORT export
 6 | #else // SHORTY_IS_IN_MODULE
 7 | #include <utility>
 8 | #endif // SHORTY_IS_IN_MODULE
 9 | 
10 | namespace shorty {
11 | 
12 | #if __cpp_pack_indexing >= 202311L
13 | template <typename... Ts> using first = Ts...[0];
14 | template <typename... Ts> constexpr auto first_thing(Ts &&... args) {
15 | 	return args...[0];
16 | }
17 | 
18 | #else
19 | 
20 | template <typename...> struct head_helper;
21 | template <typename Head, typename... Ts> struct head_helper<Head, Ts...> {
22 | 	using result = Head;
23 | };
24 | template <typename Head, typename... Ts> constexpr auto first_thing(Head && head, Ts &&...) {
25 | 	return head;
26 | }
27 | 
28 | template <typename... Ts> using first = head_helper<Ts...>::result;
29 | 
30 | template <size_t N, typename First, typename... Args> constexpr auto extract_nth(First && first, Args &&... args) noexcept {
31 | 	if constexpr (N == 0u) {
32 | 		return first;
33 | 	} else {
34 | 		return extract_nth<N - 1u>(std::forward<Args>(args)...);
35 | 	}
36 | }
37 | 
38 | #endif
39 | 
40 | } // namespace shorty
41 | 
42 | #endif // SHORTY_SHORTY_COMPATIBILITY_PACK_INDEXING_HPP
43 | 


--------------------------------------------------------------------------------
/source/shorty/leaves.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty:leaves;
 2 | 
 3 | import std;
 4 | import :pack_indexing;
 5 | import :concepts;
 6 | import :ops;
 7 | 
 8 | #ifndef SHORTY_IS_IN_MODULE
 9 | #define SHORTY_IS_IN_MODULE
10 | #endif
11 | 
12 | #include "leaves.hpp"
13 | 


--------------------------------------------------------------------------------
/source/shorty/leaves.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SHORTY_SHORTY_LEAVES_HPP
  2 | #define SHORTY_SHORTY_LEAVES_HPP
  3 | 
  4 | #ifdef SHORTY_IS_IN_MODULE
  5 | #define SHORTY_EXPORT export
  6 | #else // SHORTY_IS_IN_MODULE
  7 | #include "ops.hpp"
  8 | #include "compatibility/concepts.hpp"
  9 | #include "compatibility/pack-indexing.hpp"
 10 | #include <optional>
 11 | #include <tuple>
 12 | #include <type_traits>
 13 | #include <utility>
 14 | #include <concepts>
 15 | #define SHORTY_EXPORT
 16 | #endif // SHORTY_IS_IN_MODULE
 17 | 
 18 | namespace shorty {
 19 | 
 20 | template <typename...> struct identify;
 21 | template <auto...> struct identify_value;
 22 | 
 23 | template <typename Op, typename... Operands> struct node;
 24 | 
 25 | template <typename T> using select = std::remove_cvref_t<T>;
 26 | 
 27 | template <typename T>
 28 | concept knows_minimal_argument_count = requires {
 29 | 	requires std::same_as<std::remove_cvref_t<decltype(T::argc_at_least)>, std::size_t>;
 30 | };
 31 | 
 32 | template <typename T> concept can_calculate_exact_argument_count = requires {
 33 | 	{ T::arg_info.consistent } -> std::convertible_to<bool>;
 34 | };
 35 | 
 36 | template <typename T> concept has_group_type = requires {
 37 | 	typename std::remove_cvref_t<T>::group;
 38 | };
 39 | 
 40 | struct ast_node;
 41 | 
 42 | #if __cpp_constexpr_exceptions >= 202411L
 43 | struct shorty_constraint_failure {
 44 | 	const char * msg;
 45 | 
 46 | 	static consteval auto inconsistent() noexcept {
 47 | 		return shorty_constraint_failure{"inconsistent number of required arguments"};
 48 | 	}
 49 | 
 50 | 	static consteval auto not_enough() noexcept {
 51 | 		return shorty_constraint_failure{"not enough arguments provided (expected more)"};
 52 | 	}
 53 | 
 54 | 	static consteval auto too_much() noexcept {
 55 | 		return shorty_constraint_failure{"more arguments provided than needed"};
 56 | 	}
 57 | 
 58 | 	constexpr const char * what() const {
 59 | 		return msg;
 60 | 	}
 61 | };
 62 | #endif
 63 | 
 64 | struct incosistent_groups {
 65 | 	static constexpr bool consistent = false;
 66 | };
 67 | 
 68 | struct neutral_info {
 69 | 	static constexpr bool consistent = true;
 70 | 
 71 | 	consteval friend neutral_info operator+(neutral_info, neutral_info) noexcept {
 72 | 		return {};
 73 | 	}
 74 | };
 75 | 
 76 | consteval incosistent_groups operator+(incosistent_groups, incosistent_groups) noexcept {
 77 | 	return {};
 78 | }
 79 | 
 80 | template <typename Group> struct argument_info {
 81 | 	std::size_t min = 0;
 82 | 	static constexpr std::size_t exact = 0;
 83 | 	static constexpr bool consistent = true;
 84 | 
 85 | 	consteval operator incosistent_groups() const noexcept {
 86 | 		return {};
 87 | 	}
 88 | 
 89 | 	consteval friend argument_info operator+(const argument_info & lhs, const argument_info & rhs) noexcept {
 90 | 		return argument_info{
 91 | 			.min = std::max(lhs.min, rhs.min),
 92 | 		};
 93 | 	}
 94 | 
 95 | 	consteval friend argument_info operator+(neutral_info, const argument_info & rhs) noexcept {
 96 | 		return rhs;
 97 | 	}
 98 | 
 99 | 	consteval friend argument_info operator+(const argument_info & lhs, neutral_info) noexcept {
100 | 		return lhs;
101 | 	}
102 | 
103 | 	static consteval std::size_t exact_or(std::size_t provided) noexcept {
104 | 		return exact == std::dynamic_extent ? provided : exact;
105 | 	}
106 | 
107 | 	template <typename T> static consteval argument_info from() noexcept {
108 | 		if constexpr (knows_minimal_argument_count<T>) {
109 | 			return {.min = std::remove_cvref_t<T>::argc_at_least};
110 | 		} else {
111 | 			return {};
112 | 		}
113 | 	}
114 | };
115 | 
116 | template <typename T> static constexpr auto argument_info_about = [] {
117 | 	if constexpr (can_calculate_exact_argument_count<T>) {
118 | 		return T::arg_info;
119 | 	} else if constexpr (has_group_type<T>) {
120 | 		return argument_info<typename T::group>::template from<T>();
121 | 	} else if constexpr (knows_minimal_argument_count<T>) {
122 | 		return argument_info<default_group>{.min = std::remove_cvref_t<T>::argc_at_least};
123 | 	} else if constexpr (std::convertible_to<ast_node, T>) {
124 | 		return neutral_info{};
125 | 	} else {
126 | 		return neutral_info{};
127 | 	}
128 | }();
129 | 
130 | consteval bool validate_minimal_number_of_arguments(std::size_t provided, std::size_t expected) {
131 | 	if (expected > provided) {
132 | #if __cpp_constexpr_exceptions >= 202411L
133 | 		throw shorty_constraint_failure::not_enough();
134 | #else
135 | 		return false;
136 | #endif
137 | 	} else {
138 | 		return true;
139 | 	}
140 | }
141 | 
142 | consteval bool validate_exact_number_of_arguments(std::size_t provided, std::size_t expected) {
143 | 	if (expected != std::dynamic_extent && expected != provided) {
144 | #if __cpp_constexpr_exceptions >= 202411L
145 | 		throw shorty_constraint_failure::too_much();
146 | #else
147 | 		return false;
148 | #endif
149 | 	} else {
150 | 		return true;
151 | 	}
152 | }
153 | 
154 | template <typename... Args> consteval std::size_t gather_number_of_arguments() {
155 | 	if constexpr (sizeof...(Args) == 1 && tuple_like<first<Args...>>) {
156 | 		const std::size_t count = std::tuple_size_v<std::remove_cvref_t<first<Args...>>>;
157 | 		return count;
158 | 	} else {
159 | 		return sizeof...(Args);
160 | 	}
161 | }
162 | 
163 | // basic ast_node which is used for ADL lookup of operators
164 | struct ast_node {
165 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator<(Lhs && lhs, Rhs && rhs) {
166 | 		return node<ops::less, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
167 | 	}
168 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator<=(Lhs && lhs, Rhs && rhs) {
169 | 		return node<ops::less_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
170 | 	}
171 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator==(Lhs && lhs, Rhs && rhs) {
172 | 		return node<ops::equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
173 | 	}
174 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator!=(Lhs && lhs, Rhs && rhs) {
175 | 		return node<ops::not_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
176 | 	}
177 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator>=(Lhs && lhs, Rhs && rhs) {
178 | 		return node<ops::greater_equal, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
179 | 	}
180 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator>(Lhs && lhs, Rhs && rhs) {
181 | 		return node<ops::greater, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
182 | 	}
183 | 
184 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator+(Lhs && lhs, Rhs && rhs) {
185 | 		return node<std::plus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
186 | 	}
187 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator-(Lhs && lhs, Rhs && rhs) {
188 | 		return node<std::minus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
189 | 	}
190 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator*(Lhs && lhs, Rhs && rhs) {
191 | 		return node<std::multiplies<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
192 | 	}
193 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator/(Lhs && lhs, Rhs && rhs) {
194 | 		return node<std::divides<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
195 | 	}
196 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator%(Lhs && lhs, Rhs && rhs) {
197 | 		return node<std::modulus<>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
198 | 	}
199 | 
200 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator+=(Lhs && lhs, Rhs && rhs) {
201 | 		return node<ops::assign<std::plus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
202 | 	}
203 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator-=(Lhs && lhs, Rhs && rhs) {
204 | 		return node<ops::assign<std::minus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
205 | 	}
206 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator*=(Lhs && lhs, Rhs && rhs) {
207 | 		return node<ops::assign<std::multiplies<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
208 | 	}
209 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator/=(Lhs && lhs, Rhs && rhs) {
210 | 		return node<ops::assign<std::divides<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
211 | 	}
212 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator%=(Lhs && lhs, Rhs && rhs) {
213 | 		return node<ops::assign<std::modulus<>>, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
214 | 	}
215 | 	template <typename Self, typename Rhs> constexpr auto operator=(this Self && self, Rhs && rhs) {
216 | 		return node<ops::assign<void>, select<Self>, select<Rhs>>{std::forward<Self>(self), std::forward<Rhs>(rhs)};
217 | 	}
218 | 	template <typename Lhs, typename Rhs> friend constexpr auto operator,(Lhs && lhs, Rhs && rhs) {
219 | 		return node<ops::tuplize, select<Lhs>, select<Rhs>>{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
220 | 	}
221 | 
222 | 	template <typename Self> constexpr auto operator+(this Self && self) {
223 | 		return node<ops::unary_plus, select<Self>>{std::forward<Self>(self)};
224 | 	}
225 | 	template <typename Self> constexpr auto operator-(this Self && self) {
226 | 		return node<ops::unary_minus, select<Self>>{std::forward<Self>(self)};
227 | 	}
228 | 	template <typename Self, typename... Args> constexpr auto operator[](this Self && self, Args &&... args) {
229 | 		return node<ops::index, select<Self>, select<Args>...>{std::forward<Self>(self), std::forward<Args>(args)...};
230 | 	}
231 | 
232 | 	template <typename Self> static constexpr auto call_info = argument_info_about<std::remove_cvref_t<Self>>;
233 | 	template <typename... Args> static constexpr auto number_of_arguments = gather_number_of_arguments<Args...>();
234 | 
235 | 	// this is only called outside
236 | 	// this gymnastics is also to improve error message
237 | 	template <typename Self, typename... Args, auto argn = number_of_arguments<Args...>, auto min_argn_expected = call_info<Self>.min>
238 | 	[[nodiscard, gnu::flatten, gnu::always_inline]]
239 | 	constexpr auto operator() // calling shorty
240 | 		(this Self && self, Args &&... args) requires(validate_minimal_number_of_arguments(argn, min_argn_expected))
241 | 	{
242 | 		if constexpr (sizeof...(Args) == 1 && tuple_like<first<Args...>>) {
243 | 			auto && first_arg = first_thing(std::forward<Args>(args)...);
244 | #if __cpp_structured_bindings >= 202411L
245 | 			auto && [... subargs] = first_arg;
246 | 			return std::forward<Self>(self).operator()(std::forward<decltype(subargs)>(subargs)...);
247 | #else
248 | 			return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
249 | 				return std::forward<Self>(self).operator()(std::get<Idx>(first_arg)...);
250 | 			}(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<decltype(first_arg)>>>());
251 | #endif
252 | 		} else {
253 | 			return self.eval(std::forward<Args>(args)...);
254 | 		}
255 | 	}
256 | };
257 | 
258 | template <typename T, typename... Args> constexpr decltype(auto) evaluate(T && obj, [[maybe_unused]] Args &&... args) {
259 | 	if constexpr (requires { obj.eval(std::forward<Args>(args)...); }) {
260 | 		return obj.eval(std::forward<Args>(args)...);
261 | 	} else {
262 | 		return obj;
263 | 	}
264 | }
265 | 
266 | template <typename Op, typename... Operands> struct node: ast_node {
267 | 	static constexpr auto arg_info = (argument_info_about<std::remove_cvref_t<Operands>> + ... + neutral_info{});
268 | 	static constexpr bool consistent = arg_info.consistent;
269 | 	static_assert(consistent, "expected number of arguments is not consistent (hint: mixing something like $lhs and $x?)");
270 | 	using base_node = node;
271 | 
272 | 	static constexpr auto op = Op{};
273 | 	[[no_unique_address]] std::tuple<Operands...> ast_operands;
274 | 
275 | 	node(node &&) = default;
276 | 	node(const node &) = default;
277 | 	constexpr node(std::convertible_to<Operands> auto &&... _ast_operands): ast_operands{std::forward<decltype(_ast_operands)>(_ast_operands)...} { }
278 | 
279 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
280 | #if __cpp_structured_bindings >= 202411L
281 | 		auto && [... operands] = ast_operands;
282 | 		return op(evaluate(std::forward<decltype(operands)>(operands), std::forward<Args>(args)...)...);
283 | #else
284 | 		return [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
285 | 			return op(evaluate(std::get<Idx>(ast_operands), std::forward<Args>(args)...)...);
286 | 		}(std::make_index_sequence<std::tuple_size<decltype(ast_operands)>::value>());
287 | #endif
288 | 	}
289 | };
290 | 
291 | // this will return Nth argument from the shorty's lambda
292 | SHORTY_EXPORT template <unsigned N> struct nth_argument: ast_node {
293 | 	static constexpr std::size_t argc_at_least = N + 1;
294 | 	using group = default_group;
295 | 
296 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
297 | 		static_assert(N < sizeof...(Args));
298 | #if __cpp_pack_indexing >= 202311L
299 | 		return args...[N];
300 | #else
301 | 		return extract_nth<N>(std::forward<Args>(args)...);
302 | #endif
303 | 	}
304 | };
305 | 
306 | SHORTY_EXPORT template <unsigned N, typename Group = void> struct nth_argument_with_group: ast_node {
307 | 	static constexpr std::size_t argc_at_least = N + 1;
308 | 	using group = Group;
309 | 
310 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
311 | 		if constexpr (requires { Group::arity; }) {
312 | 			static_assert(Group::arity == sizeof...(Args));
313 | 		}
314 | 
315 | 		static_assert(N < sizeof...(Args));
316 | #if __cpp_pack_indexing >= 202311L
317 | 		return args...[N];
318 | #else
319 | 		return extract_nth<N>(std::forward<Args>(args)...);
320 | #endif
321 | 	}
322 | };
323 | 
324 | // same as `nth-argument` but `Query` callable must return true for argument of `std::type_identity<T>`
325 | SHORTY_EXPORT template <unsigned N, auto Query> struct nth_argument_with_query: ast_node {
326 | 	static constexpr std::size_t argc_at_least = N + 1;
327 | 
328 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
329 | 		static_assert(N < sizeof...(Args));
330 | #if __cpp_pack_indexing >= 202311L
331 | 		static_assert(Query(std::type_identity<Args... [N]>{}));
332 | 		return args...[N];
333 | #else
334 | 		static_assert(Query(std::type_identity<decltype(extract_nth<N>(std::forward<Args>(args)...))>{}));
335 | 		return extract_nth<N>(std::forward<Args>(args)...);
336 | #endif
337 | 	}
338 | };
339 | 
340 | // number of arguments provided to shorty's lambda
341 | SHORTY_EXPORT struct argument_count: ast_node {
342 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
343 | 		return sizeof...(Args);
344 | 	}
345 | };
346 | 
347 | // wrap all provided arguments to shorty's lambda and return a tuple
348 | SHORTY_EXPORT struct pack_arguments: ast_node {
349 | 	template <typename... Args> constexpr auto eval(Args &&... args) const {
350 | 		return std::tuple(std::forward<Args>(args)...);
351 | 	}
352 | };
353 | 
354 | // store CNTTP constant
355 | SHORTY_EXPORT template <auto V> struct constant: ast_node {
356 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
357 | 		return V;
358 | 	}
359 | };
360 | 
361 | // store a value of any type
362 | SHORTY_EXPORT template <typename T> struct value: ast_node {
363 | 	T data;
364 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
365 | 		return data;
366 | 	}
367 | };
368 | 
369 | // store a reference to a string literals
370 | SHORTY_EXPORT template <typename CharT, std::size_t N> struct static_string: ast_node {
371 | 	using type = const CharT (&)[N];
372 | 	type data;
373 | 	consteval static_string(const CharT (&_data)[N]) noexcept: data{_data} { }
374 | 	template <typename... Args> constexpr type eval(Args &&...) const {
375 | 		return data;
376 | 	}
377 | };
378 | 
379 | // external const/non-const reference
380 | SHORTY_EXPORT template <typename T> struct reference: ast_node {
381 | 	T & value;
382 | 	constexpr reference(T & _value) noexcept: value{_value} { }
383 | 	template <typename... Args> constexpr auto eval(Args &&...) const {
384 | 		return value;
385 | 	}
386 | };
387 | 
388 | } // namespace shorty
389 | 
390 | #endif // SHORTY_SHORTY_LEAVES_HPP
391 | 


--------------------------------------------------------------------------------
/source/shorty/literals.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty:literals;
 2 | 
 3 | import std;
 4 | import :leaves;
 5 | 
 6 | #ifndef SHORTY_IS_IN_MODULE
 7 | #define SHORTY_IS_IN_MODULE
 8 | #endif
 9 | 
10 | #include "literals.hpp"
11 | 


--------------------------------------------------------------------------------
/source/shorty/literals.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SHORTY_SHORTY_LITERALS_HPP
  2 | #define SHORTY_SHORTY_LITERALS_HPP
  3 | 
  4 | #ifdef SHORTY_IS_IN_MODULE
  5 | #define SHORTY_EXPORT export
  6 | #else // SHORTY_IS_IN_MODULE
  7 | #include "leaves.hpp"
  8 | #define SHORTY_EXPORT
  9 | #endif // SHORTY_IS_IN_MODULE
 10 | 
 11 | SHORTY_EXPORT namespace shorty::literals {
 12 | 	template <unsigned N> constexpr auto $arg = shorty::nth_argument<N>{};
 13 | 
 14 | 	constexpr auto $args = shorty::pack_arguments{};
 15 | 	constexpr auto $argc = shorty::argument_count{};
 16 | 	// constexpr auto $unused = shorty::argument_unused{}; all unused arguments will wrap into a tuple
 17 | 
 18 | 	// nth-argument
 19 | 	constexpr auto $0 = $arg<0>;
 20 | 	constexpr auto $1 = $arg<1>;
 21 | 	constexpr auto $2 = $arg<2>;
 22 | 	constexpr auto $3 = $arg<3>;
 23 | 	constexpr auto $4 = $arg<4>;
 24 | 	constexpr auto $5 = $arg<5>;
 25 | 	constexpr auto $6 = $arg<6>;
 26 | 	constexpr auto $7 = $arg<7>;
 27 | 	constexpr auto $8 = $arg<8>;
 28 | 	constexpr auto $9 = $arg<9>;
 29 | 
 30 | 	// #if __cpp_template_parameters >= 202502L
 31 | 	//	template <template <typename> concept C> constexpr auto @0 = $arg<0>;
 32 | 	//	template <template <typename> concept C> constexpr auto @1 = $arg<1>;
 33 | 	//	template <template <typename> concept C> constexpr auto @2 = $arg<2>;
 34 | 	//	template <template <typename> concept C> constexpr auto @3 = $arg<3>;
 35 | 	//	template <template <typename> concept C> constexpr auto @4 = $arg<4>;
 36 | 	//	template <template <typename> concept C> constexpr auto @5 = $arg<5>;
 37 | 	//	template <template <typename> concept C> constexpr auto @6 = $arg<6>;
 38 | 	//	template <template <typename> concept C> constexpr auto @7 = $arg<7>;
 39 | 	//	template <template <typename> concept C> constexpr auto @8 = $arg<8>;
 40 | 	//	template <template <typename> concept C> constexpr auto @9 = $arg<9>;
 41 | 	// #endif
 42 | 
 43 | 	// for niceness
 44 | 	constexpr auto $it = shorty::nth_argument_with_query<0, []<typename T> { return std::input_or_output_iterator<T>; }>{};
 45 | 
 46 | 	constexpr auto $i = shorty::nth_argument_with_group<0, shorty::group<1, 'i'>>{};
 47 | 	constexpr auto $n = shorty::nth_argument_with_group<0, shorty::group<1, 'n'>>{};
 48 | 	constexpr auto $k = shorty::nth_argument_with_group<0, shorty::group<1, 'k'>>{};
 49 | 
 50 | 	constexpr auto $lhs = shorty::nth_argument_with_group<0, shorty::binary_ops>{};
 51 | 	constexpr auto $rhs = shorty::nth_argument_with_group<1, shorty::binary_ops>{};
 52 | 
 53 | 	constexpr auto $in = shorty::nth_argument_with_group<0, shorty::unary_ops>{};
 54 | 
 55 | 	constexpr auto $x = shorty::nth_argument_with_group<0, shorty::xyz>{};
 56 | 	constexpr auto $y = shorty::nth_argument_with_group<1, shorty::xyz>{};
 57 | 	constexpr auto $z = shorty::nth_argument_with_group<2, shorty::xyz>{};
 58 | 
 59 | 	constexpr auto $a = shorty::nth_argument_with_group<0, shorty::abc>{};
 60 | 	constexpr auto $b = shorty::nth_argument_with_group<1, shorty::abc>{};
 61 | 	constexpr auto $c = shorty::nth_argument_with_group<2, shorty::abc>{};
 62 | 	constexpr auto $d = shorty::nth_argument_with_group<3, shorty::abc>{};
 63 | 	constexpr auto $e = shorty::nth_argument_with_group<4, shorty::abc>{};
 64 | 	constexpr auto $f = shorty::nth_argument_with_group<5, shorty::abc>{};
 65 | 
 66 | 	// `$cast<T>(expr)` or `$<T>(expr)` are lazy static_cast
 67 | 	template <typename T> constexpr auto $cast(auto && arg) {
 68 | 		return node<ops::cast<T>, select<decltype(arg)>>{std::forward<decltype(arg)>(arg)};
 69 | 	}
 70 | 	template <typename T> constexpr auto $(auto && arg) {
 71 | 		return node<ops::cast<T>, select<decltype(arg)>>{std::forward<decltype(arg)>(arg)};
 72 | 	}
 73 | 
 74 | 	// `$<fnc>(args...)` or `$call<fnc>(args...)` are lazy function
 75 | 	template <auto Op> constexpr auto $(auto &&... arg) {
 76 | 		return node<ops::call<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
 77 | 	}
 78 | 
 79 | 	template <auto Op> constexpr auto $call(auto &&... arg) {
 80 | 		return node<ops::call<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
 81 | 	}
 82 | 
 83 | 	template <typename T> concept callable = requires {
 84 | 		T::operator();
 85 | 	};
 86 | 
 87 | 	// `$<callable>(args...)` or `$call<callable>(args...)` are lazy function
 88 | 	template <callable Op> constexpr auto $(auto &&... arg) {
 89 | 		return node<ops::callable<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
 90 | 	}
 91 | 	template <typename Op> constexpr auto $call(auto &&... arg) {
 92 | 		return node<ops::callable<Op>, select<decltype(arg)>...>{std::forward<decltype(arg)>(arg)...};
 93 | 	}
 94 | 
 95 | 	// `$value(VALUE)
 96 | 	constexpr auto $value(auto && ref) noexcept {
 97 | 		return shorty::value(std::forward<decltype(ref)>(ref));
 98 | 	}
 99 | 	constexpr auto $val(auto && ref) noexcept {
100 | 		return shorty::value(std::forward<decltype(ref)>(ref));
101 | 	}
102 | 	// `$(REF)` or `$(CREF)`
103 | 	constexpr auto $(auto & ref) noexcept {
104 | 		return shorty::reference<std::remove_reference_t<decltype(ref)>>(ref);
105 | 	}
106 | 	constexpr auto $(const auto & ref) noexcept {
107 | 		return shorty::reference<const std::remove_reference_t<decltype(ref)>>(ref);
108 | 	}
109 | 	constexpr auto $ref(auto & ref) noexcept {
110 | 		return shorty::reference<std::remove_reference_t<decltype(ref)>>(ref);
111 | 	}
112 | 	constexpr auto $ref(const auto & ref) noexcept {
113 | 		return shorty::reference<const std::remove_reference_t<decltype(ref)>>(ref);
114 | 	}
115 | 	// `$const<VALUE>` (CNTTP constant)
116 | 	template <auto V> constexpr auto $const = shorty::constant<V>{};
117 | 	template <auto V> constexpr auto $fixed = shorty::constant<V>{};
118 | } // namespace shorty::literals
119 | 
120 | #endif // SHORTY_SHORTY_LITERALS_HPP
121 | 


--------------------------------------------------------------------------------
/source/shorty/ops.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty:ops;
 2 | 
 3 | import std;
 4 | import :concepts;
 5 | 
 6 | #ifndef SHORTY_IS_IN_MODULE
 7 | #define SHORTY_IS_IN_MODULE
 8 | #endif
 9 | 
10 | #include "ops.hpp"
11 | 


--------------------------------------------------------------------------------
/source/shorty/ops.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SHORTY_SHORTY_OPS_HPP
  2 | #define SHORTY_SHORTY_OPS_HPP
  3 | 
  4 | #ifdef SHORTY_IS_IN_MODULE
  5 | #define SHORTY_EXPORT export
  6 | #else // SHORTY_IS_IN_MODULE
  7 | #include "compatibility/concepts.hpp"
  8 | #include <utility>
  9 | #define SHORTY_EXPORT
 10 | #endif // SHORTY_IS_IN_MODULE
 11 | 
 12 | namespace shorty {
 13 | // groups
 14 | struct default_group {
 15 | 	// no parameter
 16 | };
 17 | struct binary_ops {
 18 | 	static constexpr std::size_t arity = 2;
 19 | };
 20 | struct unary_ops {
 21 | 	static constexpr std::size_t arity = 1;
 22 | };
 23 | template <std::size_t Arity, auto> struct group {
 24 | 	static constexpr std::size_t arity = Arity;
 25 | };
 26 | struct xyz {
 27 | };
 28 | struct abc {
 29 | };
 30 | struct ink {
 31 | };
 32 | 
 33 | } // namespace shorty
 34 | 
 35 | namespace shorty::ops {
 36 | 
 37 | // ops
 38 | struct compare {
 39 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) <=> std::forward<decltype(rhs)>(rhs))) {
 40 | 		return std::forward<decltype(lhs)>(lhs) <=> std::forward<decltype(rhs)>(rhs);
 41 | 	}
 42 | };
 43 | struct less {
 44 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) < std::forward<decltype(rhs)>(rhs))) {
 45 | 		return std::forward<decltype(lhs)>(lhs) < std::forward<decltype(rhs)>(rhs);
 46 | 	}
 47 | };
 48 | struct less_equal {
 49 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) <= std::forward<decltype(rhs)>(rhs))) {
 50 | 		return std::forward<decltype(lhs)>(lhs) <= std::forward<decltype(rhs)>(rhs);
 51 | 	}
 52 | };
 53 | struct equal {
 54 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) == std::forward<decltype(rhs)>(rhs))) {
 55 | 		return std::forward<decltype(lhs)>(lhs) == std::forward<decltype(rhs)>(rhs);
 56 | 	}
 57 | };
 58 | struct not_equal {
 59 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) != std::forward<decltype(rhs)>(rhs))) {
 60 | 		return std::forward<decltype(lhs)>(lhs) != std::forward<decltype(rhs)>(rhs);
 61 | 	}
 62 | };
 63 | struct greater_equal {
 64 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) >= std::forward<decltype(rhs)>(rhs))) {
 65 | 		return std::forward<decltype(lhs)>(lhs) >= std::forward<decltype(rhs)>(rhs);
 66 | 	}
 67 | };
 68 | struct greater {
 69 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) > std::forward<decltype(rhs)>(rhs))) {
 70 | 		return std::forward<decltype(lhs)>(lhs) > std::forward<decltype(rhs)>(rhs);
 71 | 	}
 72 | };
 73 | struct unary_plus {
 74 | 	static constexpr auto operator()(auto && val) noexcept(noexcept(+std::forward<decltype(val)>(val))) {
 75 | 		return +std::forward<decltype(val)>(val);
 76 | 	}
 77 | };
 78 | struct unary_minus {
 79 | 	static constexpr auto operator()(auto && val) noexcept(noexcept(-std::forward<decltype(val)>(val))) {
 80 | 		return -std::forward<decltype(val)>(val);
 81 | 	}
 82 | };
 83 | template <typename Op = void> struct assign;
 84 | template <typename Op> struct assign {
 85 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) = Op{}(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs)))) {
 86 | 		return lhs = Op{}(lhs, rhs);
 87 | 	}
 88 | };
 89 | 
 90 | template <> struct assign<void> {
 91 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::forward<decltype(lhs)>(lhs) = std::forward<decltype(rhs)>(rhs))) {
 92 | 		return std::forward<decltype(lhs)>(lhs) = std::forward<decltype(rhs)>(rhs);
 93 | 	}
 94 | };
 95 | 
 96 | struct tuplize {
 97 | 	static constexpr auto operator()(auto && lhs, auto && rhs) noexcept(noexcept(std::make_tuple(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs)))) {
 98 | 		return std::make_tuple(std::forward<decltype(lhs)>(lhs), std::forward<decltype(rhs)>(rhs));
 99 | 	}
100 | 	static constexpr auto operator()(tuple_like auto && lhs, auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
101 | 		return std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs)));
102 | 	}
103 | 	static constexpr auto operator()(auto && lhs, tuple_like auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
104 | 		return std::tuple_cat(std::make_tuple(std::forward<decltype(lhs)>(lhs)), std::forward<decltype(rhs)>(rhs));
105 | 	}
106 | 	static constexpr auto operator()(tuple_like auto && lhs, tuple_like auto && rhs) noexcept(noexcept(std::tuple_cat(std::forward<decltype(lhs)>(lhs), std::make_tuple(std::forward<decltype(rhs)>(rhs))))) {
107 | 		return std::tuple_cat(std::make_tuple(std::forward<decltype(lhs)>(lhs)), std::make_tuple(std::forward<decltype(rhs)>(rhs)));
108 | 	}
109 | };
110 | 
111 | template <typename...> struct identify;
112 | 
113 | struct index {
114 | #pragma clang diagnostic push
115 | #pragma clang diagnostic ignored "-Wsign-conversion"
116 | 	static constexpr auto operator()(auto && subject, auto &&... args) noexcept(noexcept(std::forward<decltype(subject)>(subject)[std::forward<decltype(args)>(args)...])) {
117 | 		return std::forward<decltype(subject)>(subject)[std::forward<decltype(args)>(args)...];
118 | 	}
119 | #pragma clang diagnostic pop
120 | };
121 | 
122 | template <typename T> struct cast {
123 | 	static constexpr auto operator()(auto && arg) noexcept(noexcept(static_cast<T>(std::forward<decltype(arg)>(arg)))) {
124 | 		return static_cast<T>(std::forward<decltype(arg)>(arg));
125 | 	}
126 | };
127 | 
128 | template <auto Op> struct call {
129 | 	static constexpr auto operator()(auto &&... args) noexcept(noexcept(Op(std::forward<decltype(args)>(args)...))) {
130 | 		return Op(std::forward<decltype(args)>(args)...);
131 | 	}
132 | 	//
133 | 	// static constexpr auto operator()(tuple_like auto & arg) noexcept(noexcept(Op(std::forward<decltype(args)>(args)...))) {
134 | 	//	return Op(std::forward<decltype(args)>(args)...);
135 | 	//}
136 | };
137 | 
138 | template <typename Op> struct callable {
139 | 	static constexpr auto operator()(auto &&... args) noexcept(noexcept(Op{}(std::forward<decltype(args)>(args)...))) {
140 | 		return Op{}(std::forward<decltype(args)>(args)...);
141 | 	}
142 | 	// unwrap tuple for us
143 | 	static constexpr auto operator()(tuple_like auto && tuple_arg) noexcept(noexcept(std::apply(callable::operator(), std::forward<decltype(tuple_arg)>(tuple_arg)))) {
144 | 		return std::apply(callable::operator(), std::forward<decltype(tuple_arg)>(tuple_arg));
145 | 	}
146 | };
147 | 
148 | } // namespace shorty::ops
149 | 
150 | #endif // SHORTY_SHORTY_OPS_HPP
151 | 


--------------------------------------------------------------------------------
/source/shorty/shorty.cppm:
--------------------------------------------------------------------------------
 1 | export module shorty;
 2 | 
 3 | import std;
 4 | export import :literals;
 5 | export import :concepts;
 6 | 
 7 | #ifndef SHORTY_IS_IN_MODULE
 8 | #define SHORTY_IS_IN_MODULE
 9 | #endif
10 | 
11 | #include "shorty.hpp"
12 | 


--------------------------------------------------------------------------------
/source/shorty/shorty.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SHORTY_SHORTY_HPP
 2 | #define SHORTY_SHORTY_HPP
 3 | 
 4 | #ifdef SHORTY_IS_IN_MODULE
 5 | #define SHORTY_EXPORT export
 6 | #else // SHORTY_IS_IN_MODULE
 7 | #include "literals.hpp"
 8 | #define SHORTY_EXPORT
 9 | #endif // SHORTY_IS_IN_MODULE
10 | 
11 | SHORTY_EXPORT template <typename...> struct identify;
12 | 
13 | namespace shorty {
14 | 
15 | }
16 | 
17 | #endif // SHORTY_SHORTY_HPP
18 | 


--------------------------------------------------------------------------------