Skip to content

Commit cef96d8

Browse files
GoNZoooGoNZooo
committed
modify test & example files with new restrictions
Since this is now more strict some examples had to be changed to match the new behavior.
1 parent 6cca4b3 commit cef96d8

File tree

3 files changed

+117
-117
lines changed

3 files changed

+117
-117
lines changed

‎test_files/basic.gotyno

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,11 @@ struct Recruiter {
22
name: String
33
}
44

5+
union Maybe <T>{
6+
Nothing
7+
Just: T
8+
}
9+
510
struct Person {
611
name: String
712
age: U8
@@ -38,11 +43,6 @@ union Event {
3843
SetEmails: [5]Email
3944
}
4045

41-
union Maybe <T>{
42-
Nothing
43-
Just: T
44-
}
45-
4646
union Either <L, R>{
4747
Left: L
4848
Right: R

‎test_files/basic.ts

Lines changed: 56 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,62 @@ export function validateRecruiter(value: unknown): svt.ValidationResult<Recruite
1212
return svt.validate<Recruiter>(value, {name: svt.validateString});
1313
}
1414

15+
export type Maybe<T> = Nothing | Just<T>;
16+
17+
export enum MaybeTag {
18+
Nothing = "Nothing",
19+
Just = "Just",
20+
}
21+
22+
export type Nothing = {
23+
type: MaybeTag.Nothing;
24+
};
25+
26+
export type Just<T> = {
27+
type: MaybeTag.Just;
28+
data: T;
29+
};
30+
31+
export function Nothing(): Nothing {
32+
return {type: MaybeTag.Nothing};
33+
}
34+
35+
export function Just<T>(data: T): Just<T> {
36+
return {type: MaybeTag.Just, data};
37+
}
38+
39+
export function isMaybe<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Maybe<T>> {
40+
return function isMaybeT(value: unknown): value is Maybe<T> {
41+
return [isNothing, isJust(isT)].some((typePredicate) => typePredicate(value));
42+
};
43+
}
44+
45+
export function isNothing(value: unknown): value is Nothing {
46+
return svt.isInterface<Nothing>(value, {type: MaybeTag.Nothing});
47+
}
48+
49+
export function isJust<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Just<T>> {
50+
return function isJustT(value: unknown): value is Just<T> {
51+
return svt.isInterface<Just<T>>(value, {type: MaybeTag.Just, data: isT});
52+
};
53+
}
54+
55+
export function validateMaybe<T>(validateT: svt.Validator<T>): svt.Validator<Maybe<T>> {
56+
return function validateMaybeT(value: unknown): svt.ValidationResult<Maybe<T>> {
57+
return svt.validateOneOf<Maybe<T>>(value, [validateNothing, validateJust(validateT)]);
58+
};
59+
}
60+
61+
export function validateNothing(value: unknown): svt.ValidationResult<Nothing> {
62+
return svt.validate<Nothing>(value, {type: MaybeTag.Nothing});
63+
}
64+
65+
export function validateJust<T>(validateT: svt.Validator<T>): svt.Validator<Just<T>> {
66+
return function validateJustT(value: unknown): svt.ValidationResult<Just<T>> {
67+
return svt.validate<Just<T>>(value, {type: MaybeTag.Just, data: validateT});
68+
};
69+
}
70+
1571
export type Person = {
1672
name: string;
1773
age: number;
@@ -166,62 +222,6 @@ export function validateSetEmails(value: unknown): svt.ValidationResult<SetEmail
166222
return svt.validate<SetEmails>(value, {type: EventTag.SetEmails, data: svt.validateArray(validateEmail)});
167223
}
168224

169-
export type Maybe<T> = Nothing | Just<T>;
170-
171-
export enum MaybeTag {
172-
Nothing = "Nothing",
173-
Just = "Just",
174-
}
175-
176-
export type Nothing = {
177-
type: MaybeTag.Nothing;
178-
};
179-
180-
export type Just<T> = {
181-
type: MaybeTag.Just;
182-
data: T;
183-
};
184-
185-
export function Nothing(): Nothing {
186-
return {type: MaybeTag.Nothing};
187-
}
188-
189-
export function Just<T>(data: T): Just<T> {
190-
return {type: MaybeTag.Just, data};
191-
}
192-
193-
export function isMaybe<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Maybe<T>> {
194-
return function isMaybeT(value: unknown): value is Maybe<T> {
195-
return [isNothing, isJust(isT)].some((typePredicate) => typePredicate(value));
196-
};
197-
}
198-
199-
export function isNothing(value: unknown): value is Nothing {
200-
return svt.isInterface<Nothing>(value, {type: MaybeTag.Nothing});
201-
}
202-
203-
export function isJust<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Just<T>> {
204-
return function isJustT(value: unknown): value is Just<T> {
205-
return svt.isInterface<Just<T>>(value, {type: MaybeTag.Just, data: isT});
206-
};
207-
}
208-
209-
export function validateMaybe<T>(validateT: svt.Validator<T>): svt.Validator<Maybe<T>> {
210-
return function validateMaybeT(value: unknown): svt.ValidationResult<Maybe<T>> {
211-
return svt.validateOneOf<Maybe<T>>(value, [validateNothing, validateJust(validateT)]);
212-
};
213-
}
214-
215-
export function validateNothing(value: unknown): svt.ValidationResult<Nothing> {
216-
return svt.validate<Nothing>(value, {type: MaybeTag.Nothing});
217-
}
218-
219-
export function validateJust<T>(validateT: svt.Validator<T>): svt.Validator<Just<T>> {
220-
return function validateJustT(value: unknown): svt.ValidationResult<Just<T>> {
221-
return svt.validate<Just<T>>(value, {type: MaybeTag.Just, data: validateT});
222-
};
223-
}
224-
225225
export type Either<L, R> = Left<L> | Right<R>;
226226

227227
export enum EitherTag {

‎test_files/test.ts

Lines changed: 56 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,62 @@ export function validateRecruiter(value: unknown): svt.ValidationResult<Recruite
1212
return svt.validate<Recruiter>(value, {name: svt.validateString});
1313
}
1414

15+
export type Maybe<T> = Nothing | Just<T>;
16+
17+
export enum MaybeTag {
18+
Nothing = "Nothing",
19+
Just = "Just",
20+
}
21+
22+
export type Nothing = {
23+
type: MaybeTag.Nothing;
24+
};
25+
26+
export type Just<T> = {
27+
type: MaybeTag.Just;
28+
data: T;
29+
};
30+
31+
export function Nothing(): Nothing {
32+
return {type: MaybeTag.Nothing};
33+
}
34+
35+
export function Just<T>(data: T): Just<T> {
36+
return {type: MaybeTag.Just, data};
37+
}
38+
39+
export function isMaybe<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Maybe<T>> {
40+
return function isMaybeT(value: unknown): value is Maybe<T> {
41+
return [isNothing, isJust(isT)].some((typePredicate) => typePredicate(value));
42+
};
43+
}
44+
45+
export function isNothing(value: unknown): value is Nothing {
46+
return svt.isInterface<Nothing>(value, {type: MaybeTag.Nothing});
47+
}
48+
49+
export function isJust<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Just<T>> {
50+
return function isJustT(value: unknown): value is Just<T> {
51+
return svt.isInterface<Just<T>>(value, {type: MaybeTag.Just, data: isT});
52+
};
53+
}
54+
55+
export function validateMaybe<T>(validateT: svt.Validator<T>): svt.Validator<Maybe<T>> {
56+
return function validateMaybeT(value: unknown): svt.ValidationResult<Maybe<T>> {
57+
return svt.validateOneOf<Maybe<T>>(value, [validateNothing, validateJust(validateT)]);
58+
};
59+
}
60+
61+
export function validateNothing(value: unknown): svt.ValidationResult<Nothing> {
62+
return svt.validate<Nothing>(value, {type: MaybeTag.Nothing});
63+
}
64+
65+
export function validateJust<T>(validateT: svt.Validator<T>): svt.Validator<Just<T>> {
66+
return function validateJustT(value: unknown): svt.ValidationResult<Just<T>> {
67+
return svt.validate<Just<T>>(value, {type: MaybeTag.Just, data: validateT});
68+
};
69+
}
70+
1571
export type Person = {
1672
name: string;
1773
age: number;
@@ -166,62 +222,6 @@ export function validateSetEmails(value: unknown): svt.ValidationResult<SetEmail
166222
return svt.validate<SetEmails>(value, {type: EventTag.SetEmails, data: svt.validateArray(validateEmail)});
167223
}
168224

169-
export type Maybe<T> = Nothing | Just<T>;
170-
171-
export enum MaybeTag {
172-
Nothing = "Nothing",
173-
Just = "Just",
174-
}
175-
176-
export type Nothing = {
177-
type: MaybeTag.Nothing;
178-
};
179-
180-
export type Just<T> = {
181-
type: MaybeTag.Just;
182-
data: T;
183-
};
184-
185-
export function Nothing(): Nothing {
186-
return {type: MaybeTag.Nothing};
187-
}
188-
189-
export function Just<T>(data: T): Just<T> {
190-
return {type: MaybeTag.Just, data};
191-
}
192-
193-
export function isMaybe<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Maybe<T>> {
194-
return function isMaybeT(value: unknown): value is Maybe<T> {
195-
return [isNothing, isJust(isT)].some((typePredicate) => typePredicate(value));
196-
};
197-
}
198-
199-
export function isNothing(value: unknown): value is Nothing {
200-
return svt.isInterface<Nothing>(value, {type: MaybeTag.Nothing});
201-
}
202-
203-
export function isJust<T>(isT: svt.TypePredicate<T>): svt.TypePredicate<Just<T>> {
204-
return function isJustT(value: unknown): value is Just<T> {
205-
return svt.isInterface<Just<T>>(value, {type: MaybeTag.Just, data: isT});
206-
};
207-
}
208-
209-
export function validateMaybe<T>(validateT: svt.Validator<T>): svt.Validator<Maybe<T>> {
210-
return function validateMaybeT(value: unknown): svt.ValidationResult<Maybe<T>> {
211-
return svt.validateOneOf<Maybe<T>>(value, [validateNothing, validateJust(validateT)]);
212-
};
213-
}
214-
215-
export function validateNothing(value: unknown): svt.ValidationResult<Nothing> {
216-
return svt.validate<Nothing>(value, {type: MaybeTag.Nothing});
217-
}
218-
219-
export function validateJust<T>(validateT: svt.Validator<T>): svt.Validator<Just<T>> {
220-
return function validateJustT(value: unknown): svt.ValidationResult<Just<T>> {
221-
return svt.validate<Just<T>>(value, {type: MaybeTag.Just, data: validateT});
222-
};
223-
}
224-
225225
export type Either<L, R> = Left<L> | Right<R>;
226226

227227
export enum EitherTag {

0 commit comments

Comments
 (0)