source: tests/function-operator.cfa @ 8419b76

ADTast-experimentalpthread-emulationqualifiedEnum
Last change on this file since 8419b76 was fd54fef, checked in by Michael Brooks <mlbrooks@…>, 4 years ago

Converting the project to use the new syntax for otype, dtype and ttytpe.

Changed prelude (gen), libcfa and test suite to use it. Added a simple deprecation rule of the old syntax to the parser; we might wish to support both syntaxes "officially," like with an extra CLI switch, but this measure should serve as a simple reminder for our team to try the new syntax.

  • Property mode set to 100644
File size: 4.8 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// function-operator.c --
8//
9// Author           : Rob Schluntz
10// Created On       : Fri Aug 25 15:21:11 2017
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Apr 11 18:27:45 2019
13// Update Count     : 10
14//
15
16#include <fstream.hfa>
17#include <stdlib.hfa>
18
19#define length(array) (sizeof((array))/sizeof((array)[0]))
20#define begin(array) (&array[0]) // there's currently a bug in passing an array to a polymorphic function, so ensure a pointer is passed instead
21#define end(array) (&array[length(array)])
22
23// STL-like Algorithms
24trait Assignable(T &, U &) { T ?=?(T &, U); };
25trait Copyable(T &) { void ?{}(T &, T); };
26trait Destructable(T &) { void ^?{}(T &); };
27
28trait Iterator(iter & | sized(iter) | Copyable(iter) | Destructable(iter), T) {
29        T & *?(iter);
30        iter ++?(iter &);
31        int ?!=?(iter, iter);
32};
33
34forall(Tin, Input & | Iterator(Input, Tin), Tout, Output & | Iterator(Output, Tout) | Assignable(Tout, Tin))
35Output copy(Input first, Input last, Output result) {
36        while (first != last) {
37                *result = *first;
38                ++result; ++first;
39        }
40        return result;
41}
42
43// test ?()(T *, ...) -- ?() with function call-by-pointer
44forall(Tin, Input & | Iterator(Input, Tin), Tout, Output & | Iterator(Output, Tout), FuncRet, Func & | { FuncRet ?()(Func *, Tin); } | Assignable(Tout, FuncRet))
45Output transform (Input first, Input last, Output result, Func * op) {
46        while (first != last) {
47                *result = op(*first);
48                ++result; ++first;
49        }
50        return result;
51}
52
53// test ?()(T, ...) -- ?() with function call-by-value
54forall(Iter &, T | Iterator(Iter, T), Pred | { int ?()(Pred, T); })
55Iter find_if (Iter first, Iter last, Pred pred) {
56        while (first != last) {
57                if (pred(*first)) return first;
58                ++first;
59        }
60        return last;
61}
62
63// test ?()(T, ...) -- ?() with function call-by-reference
64forall(Generator, GenRet | { GenRet ?()(Generator &); }, Iter &, T | Iterator(Iter, T) | Assignable(T, GenRet))
65void generate(Iter first, Iter last, Generator & gen) {
66        int i = 0;
67        while (first != last) {
68                *first = gen();
69                ++first;
70        }
71}
72
73// encapsulate a counter that increments by one every time it is called
74struct Counter { int c; };
75void ?{}(Counter & cnt) { cnt.c = 0; }
76int ?()(Counter & cnt) { return cnt.c++; }
77
78// TODO: abstract over os type with ostream trait; resolver is currently too slow for this to be reasonable, but it does work.
79struct os_wrapper {
80        ofstream * out;
81};
82
83// TODO: abstract over (os, T)
84os_wrapper ?=?(os_wrapper & wrapper, int x) {
85        *wrapper.out | x;
86        return wrapper;
87}
88
89        struct ostream_iterator {
90                os_wrapper * out;
91        };
92void ?{}(ostream_iterator & iter, ofstream * out) {
93        iter.out = new(out);
94}
95// no destructor, memory leak. This is necessary for this to work at the moment, since
96// *? requires its parameter by value and returns a reference.
97
98// implement Iterator
99os_wrapper & *?(ostream_iterator iter) {
100        return *iter.out;
101}
102ostream_iterator ++?(ostream_iterator & iter) {
103        // nothing to do
104        return iter;
105}
106int ?!=?(ostream_iterator i1, ostream_iterator i2) {
107        return i1.out->out != i2.out->out;
108}
109
110forall(T | { int ?==?(T, T); })
111struct Equals {
112        T val;
113};
114
115forall(T | { int ?==?(T, T); })
116int ?()(Equals(T) eq, T x) {
117        return eq.val == x;
118}
119
120forall(T | { T ?*?(T, T); })
121struct Multiply {
122        T val;
123};
124
125forall(T | { T ?*?(T, T); })
126T ?()(Multiply(T) * mult, T x) {
127        return mult->val * x;
128}
129
130// TODO: generalize to ttype return; doesn't work yet
131// like std::function
132forall(Return, Args...)
133struct function {
134        Return (*f)(Args);
135};
136// TODO: missing adapter in these functions
137// // value, reference, pointer operators
138// forall(otype Return, ttype Args) Return ?()(function(Return, Args) func, Args args) { return func.f(args); }
139// forall(otype Return, ttype Args) Return ?()(function(Return, Args) & func, Args args) { return func.f(args); }
140// forall(otype Return, ttype Args) Return ?()(function(Return, Args) * func, Args args) { return func->f(args); }
141
142int main() {
143        // generate for array fill
144        Counter c;
145        int x[10], y[10];
146        generate(begin(x), end(x), c);
147        generate(begin(y), end(y), c);
148
149        // copy for output
150        ostream_iterator out_iter = { &sout };
151        copy(begin(x), end(x), out_iter);
152        copy(begin(y), end(y), out_iter);
153
154        // find_if for searching
155        Equals(int) is5 = { 5 };
156        if (find_if(begin(x), end(x), is5) != end(y)) {
157                printf("Found 5 in x.\n");
158        } else {
159                printf("Did not find 5 in x.\n");
160        }
161        if (find_if(begin(y), end(y), is5) != end(y)) {
162                printf("Found 5 in y.\n");
163        } else {
164                printf("Did not find 5 in y.\n");
165        }
166
167        Multiply(int) times2 = { 2 };
168        transform(begin(x), end(x), begin(x), &times2);
169        copy(begin(x), end(x), out_iter);
170
171        // REMOVE WHEN ?* PROBLEM FIXED.
172        delete(out_iter.out);
173}
174
175// Local Variables: //
176// tab-width: 4 //
177// End: //
Note: See TracBrowser for help on using the repository browser.