Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commite50aec0

Browse files
committed
interpreters
1 parent24658de commite50aec0

File tree

6 files changed

+434
-0
lines changed

6 files changed

+434
-0
lines changed
Lines changed: 109 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,109 @@
1+
packagecom.jnape.palatable.lambda.monad.transformer.interpreter;
2+
3+
importcom.jnape.palatable.lambda.adt.Either;
4+
importcom.jnape.palatable.lambda.adt.Maybe;
5+
importcom.jnape.palatable.lambda.adt.hlist.Tuple2;
6+
importcom.jnape.palatable.lambda.functions.Fn0;
7+
importcom.jnape.palatable.lambda.functions.Fn1;
8+
importcom.jnape.palatable.lambda.functor.builtin.Identity;
9+
importcom.jnape.palatable.lambda.io.IO;
10+
importcom.jnape.palatable.lambda.monad.MonadRec;
11+
importcom.jnape.palatable.lambda.monad.transformer.builtin.*;
12+
importcom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters.Transformers;
13+
14+
importstaticcom.jnape.palatable.lambda.adt.Either.left;
15+
importstaticcom.jnape.palatable.lambda.adt.Either.right;
16+
importstaticcom.jnape.palatable.lambda.adt.Maybe.just;
17+
importstaticcom.jnape.palatable.lambda.io.IO.io;
18+
importstaticcom.jnape.palatable.lambda.monad.transformer.builtin.EitherT.eitherT;
19+
importstaticcom.jnape.palatable.lambda.monad.transformer.builtin.IdentityT.identityT;
20+
importstaticcom.jnape.palatable.lambda.monad.transformer.builtin.MaybeT.maybeT;
21+
importstaticcom.jnape.palatable.lambda.monad.transformer.builtin.ReaderT.readerT;
22+
importstaticcom.jnape.palatable.lambda.monad.transformer.builtin.StateT.liftStateT;
23+
importstaticcom.jnape.palatable.lambda.monad.transformer.interpreter.InterpreterH.InterpreterHs.interpretIdentityT;
24+
importstaticcom.jnape.palatable.lambda.monad.transformer.interpreter.InterpreterH.lifting;
25+
importstaticcom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters.Transformers.*;
26+
importstaticcom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters.transformers.Construction.eitherT;
27+
28+
publicclassExample {
29+
publicstaticvoidsimpleCase() {
30+
EitherT<IO<?>,String,Integer>eitherT =eitherT(io(() ->right(1)));
31+
Transformers.<IO<?>,String,Integer>runEitherT()
32+
.<IO<Either<String,Integer>>>interpret(eitherT)
33+
.flatMap(res ->io(() ->System.out.println("res (" +res.getClass().getName() +"): " +res)))
34+
.unsafePerformIO();
35+
}
36+
37+
publicstaticvoidnested() {
38+
EitherT<MaybeT<IO<?>, ?>,String,Integer>effect =
39+
eitherT(maybeT(io(() ->just(left("yeh nah")))));
40+
41+
Interpreter<EitherT<MaybeT<IO<?>, ?>,String, ?>,Integer,IO<?>,Maybe<Either<String,Integer>>>voila =
42+
Transformers.<MaybeT<IO<?>, ?>,String,Integer>runEitherT()
43+
.andThen(runMaybeT());
44+
45+
voila
46+
.<IO<Maybe<Either<String,Integer>>>>interpret(effect)
47+
.flatMap(res ->io(() ->System.out.println("res (" +res.getClass().getName() +"): " +res)))
48+
.unsafePerformIO();
49+
}
50+
51+
publicstaticfinalclassRoutingContext {
52+
}
53+
54+
publicstaticfinalclassEnvelope<A> {
55+
}
56+
57+
publicstaticinterfaceEnvelopeHandler<MextendsMonadRec<?,M>,A> {
58+
MonadRec<Envelope<A>,M>handle(RoutingContextroutingContext);
59+
}
60+
61+
publicstaticinterfaceIOEnvelopeHandler<A>extendsEnvelopeHandler<IO<?>,A> {
62+
}
63+
64+
publicstaticvoiddeeplyNested() {
65+
Fn1<String,Integer>recoveryFn =String::length;
66+
Fn0<Integer>orElseGet = () -> -1;
67+
68+
Interpreter<EitherT<MaybeT<IdentityT<IO<?>, ?>, ?>,String, ?>,Integer,IO<?>,Integer>interpreter =
69+
Transformers.<MaybeT<IdentityT<IO<?>, ?>, ?>,String,Integer>interpretEitherT(recoveryFn)
70+
.andThen(interpretMaybeT(orElseGet))
71+
.andThenH(interpretIdentityT());
72+
73+
interpreter
74+
.<IO<Integer>>interpret(eitherT(maybeT(identityT(io(() ->newIdentity<>(just(right(42))))))))
75+
.flatMap(res ->io(() ->System.out.println("res (" +res.getClass().getName() +"): " +res)))
76+
.unsafePerformIO();
77+
}
78+
79+
publicstaticvoidreaderTCase() {
80+
ReaderT<Boolean,EitherT<IO<?>,String, ?>,Integer>transactional =
81+
readerT(f ->eitherT(f ?io(() ->right((int)Math.round(Math.random() *100))) :io(left("foo"))));
82+
83+
// F a -> G b
84+
Interpreter<
85+
// F a
86+
ReaderT<Boolean,EitherT<IO<?>,String, ?>, ?>,Integer,
87+
// G b
88+
IO<?>,Tuple2<Either<String,Integer>,Integer>
89+
>massiveInterpreter =
90+
Transformers.<Boolean,EitherT<IO<?>,String, ?>>runReaderT(true)
91+
.<IO<?>,Integer,Either<String,Integer>>andThen(runEitherT())
92+
.<StateT<Integer,IO<?>, ?>>andThenH(lifting(liftStateT()))
93+
.andThen(eitherT())
94+
.andThen(runEitherT())
95+
.andThen(runStateT(10));
96+
97+
massiveInterpreter
98+
.<IO<Tuple2<Either<String,Integer>,Integer>>>interpret(transactional)
99+
.flatMap(res ->io(() ->System.out.println("res (" +res.getClass().getName() +"): " +res)))
100+
.unsafePerformIO();
101+
}
102+
103+
publicstaticvoidmain(String[]args) {
104+
simpleCase();
105+
nested();
106+
deeplyNested();
107+
readerTCase();
108+
}
109+
}
Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
packagecom.jnape.palatable.lambda.monad.transformer.interpreter;
2+
3+
importcom.jnape.palatable.lambda.functions.specialized.Lift;
4+
importcom.jnape.palatable.lambda.monad.MonadRec;
5+
importcom.jnape.palatable.lambda.monad.transformer.MonadT;
6+
7+
publicinterfaceInterpreter<FextendsMonadRec<?,F>,A,GextendsMonadRec<?,G>,B> {
8+
9+
<GBextendsMonadRec<B,G>>GBinterpret(MonadRec<A,F>fa);
10+
11+
default <HextendsMonadRec<?,H>,C>Interpreter<F,A,H,C>andThen(Interpreter<G,B,H,C>ghbc) {
12+
returnnewInterpreter<F,A,H,C>() {
13+
@Override
14+
public <HCextendsMonadRec<C,H>>HCinterpret(MonadRec<A,F>fa) {
15+
returnghbc.interpret(Interpreter.this.interpret(fa));
16+
}
17+
};
18+
}
19+
20+
default <HextendsMonadRec<?,H>>Interpreter<F,A,H,B>andThenH(InterpreterH<G,H>gh) {
21+
returnnewInterpreter<F,A,H,B>() {
22+
@Override
23+
public <GBextendsMonadRec<B,H>>GBinterpret(MonadRec<A,F>fa) {
24+
returngh.interpretH(Interpreter.this.interpret(fa));
25+
}
26+
};
27+
}
28+
29+
default <EextendsMonadRec<?,E>,Z>Interpreter<E,Z,G,B>compose(Interpreter<E,Z,F,A>efza) {
30+
returnefza.andThen(this);
31+
}
32+
33+
default <EextendsMonadRec<?,E>>Interpreter<E,A,G,B>composeH(InterpreterH<E,F>ef) {
34+
returnnewInterpreter<E,A,G,B>() {
35+
@Override
36+
public <GBextendsMonadRec<B,G>>GBinterpret(MonadRec<A,E>ea) {
37+
returnInterpreter.this.interpret(ef.interpretH(ea));
38+
}
39+
};
40+
}
41+
42+
static <FextendsMonadRec<?,F>,A>Interpreter<F,A,F,A>identity() {
43+
returnnewInterpreter<F,A,F,A>() {
44+
@Override
45+
public <GBextendsMonadRec<A,F>>GBinterpret(MonadRec<A,F>fa) {
46+
returnfa.coerce();
47+
}
48+
};
49+
}
50+
51+
static <FextendsMonadRec<?,F>,TextendsMonadT<?, ?, ?,T>,GextendsMonadT<F, ?,G,T>,A>
52+
Interpreter<F,A,G,A>lifting(Lift<T>liftT) {
53+
returnnewInterpreter<F,A,G,A>() {
54+
@Override
55+
public <GBextendsMonadRec<A,G>>GBinterpret(MonadRec<A,F>fa) {
56+
returnliftT.<A,F,MonadT<F,A,G,T>>apply(fa).coerce();
57+
}
58+
};
59+
}
60+
}
Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
packagecom.jnape.palatable.lambda.monad.transformer.interpreter;
2+
3+
importcom.jnape.palatable.lambda.functions.specialized.Lift;
4+
importcom.jnape.palatable.lambda.functor.builtin.Identity;
5+
importcom.jnape.palatable.lambda.monad.MonadRec;
6+
importcom.jnape.palatable.lambda.monad.transformer.MonadT;
7+
importcom.jnape.palatable.lambda.monad.transformer.builtin.IdentityT;
8+
9+
publicinterfaceInterpreterH<FextendsMonadRec<?,F>,GextendsMonadRec<?,G>> {
10+
11+
<A,GAextendsMonadRec<A,G>>GAinterpretH(MonadRec<A,F>fa);
12+
13+
default <HextendsMonadRec<?,H>>InterpreterH<F,H>andThenH(InterpreterH<G,H>gh) {
14+
returnnewInterpreterH<F,H>() {
15+
@Override
16+
public <A,HAextendsMonadRec<A,H>>HAinterpretH(MonadRec<A,F>fa) {
17+
returngh.interpretH(InterpreterH.this.interpretH(fa));
18+
}
19+
};
20+
}
21+
22+
default <HextendsMonadRec<?,H>,A,B>Interpreter<F,A,H,B>andThen(Interpreter<G,A,H,B>gh) {
23+
returngh.composeH(this);
24+
}
25+
26+
default <EextendsMonadRec<?,E>>InterpreterH<E,G>composeH(InterpreterH<E,F>ef) {
27+
returnef.andThenH(this);
28+
}
29+
30+
default <EextendsMonadRec<?,E>,A,B>Interpreter<E,A,G,B>compose(Interpreter<E,A,F,B>gh) {
31+
returngh.andThenH(this);
32+
}
33+
34+
default <A>Interpreter<F,A,G,A>monomorphize() {
35+
returnnewInterpreter<F,A,G,A>() {
36+
@Override
37+
public <GAextendsMonadRec<A,G>>GAinterpret(MonadRec<A,F>fa) {
38+
returninterpretH(fa);
39+
}
40+
};
41+
}
42+
43+
static <FextendsMonadRec<?,F>>InterpreterH<F,F>identity() {
44+
returnnewInterpreterH<F,F>() {
45+
@Override
46+
public <A,GAextendsMonadRec<A,F>>GAinterpretH(MonadRec<A,F>fa) {
47+
returnfa.coerce();
48+
}
49+
};
50+
}
51+
52+
static <FextendsMonadRec<?,F>,TextendsMonadT<?, ?, ?,T>,GextendsMonadT<F, ?,G,T>>InterpreterH<F,G>
53+
lifting(Lift<T>liftT) {
54+
returnnewInterpreterH<F,G>() {
55+
@Override
56+
public <A,GAextendsMonadRec<A,G>>GAinterpretH(MonadRec<A,F>fa) {
57+
returnliftT.<A,F,MonadT<F,A,G,T>>apply(fa).coerce();
58+
}
59+
};
60+
}
61+
62+
static <FextendsMonadRec<?,F>,TextendsMonadT<?, ?, ?,T>,GextendsMonadT<F, ?,G,T>>InterpreterH<F,G>
63+
constructing(Lift<T>liftT) {
64+
returnnewInterpreterH<F,G>() {
65+
@Override
66+
public <A,GAextendsMonadRec<A,G>>GAinterpretH(MonadRec<A,F>fa) {
67+
returnliftT.<A,F,MonadT<F,A,G,T>>apply(fa).coerce();
68+
}
69+
};
70+
}
71+
72+
finalclassInterpreterHs {
73+
privateInterpreterHs() {
74+
}
75+
76+
publicstatic <FextendsMonadRec<?,F>>InterpreterH<IdentityT<F, ?>,F>interpretIdentityT() {
77+
returnnewInterpreterH<IdentityT<F, ?>,F>() {
78+
@Override
79+
public <A,GAextendsMonadRec<A,F>>GAinterpretH(MonadRec<A,IdentityT<F, ?>>fa) {
80+
returnfa.<IdentityT<F,A>>coerce().runIdentityT().fmap(Identity::runIdentity).coerce();
81+
}
82+
};
83+
}
84+
}
85+
86+
}
Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,82 @@
1+
packagecom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters;
2+
3+
importcom.jnape.palatable.lambda.adt.Either;
4+
importcom.jnape.palatable.lambda.adt.Maybe;
5+
importcom.jnape.palatable.lambda.adt.hlist.Tuple2;
6+
importcom.jnape.palatable.lambda.functions.Fn0;
7+
importcom.jnape.palatable.lambda.functions.Fn1;
8+
importcom.jnape.palatable.lambda.functor.builtin.Identity;
9+
importcom.jnape.palatable.lambda.monad.MonadRec;
10+
importcom.jnape.palatable.lambda.monad.transformer.builtin.*;
11+
importcom.jnape.palatable.lambda.monad.transformer.interpreter.Interpreter;
12+
importcom.jnape.palatable.lambda.monad.transformer.interpreter.InterpreterH;
13+
14+
importstaticcom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters.Values.*;
15+
16+
publicfinalclassTransformers {
17+
privateTransformers() {
18+
}
19+
20+
publicstatic <FextendsMonadRec<?,F>,L,R>Interpreter<EitherT<F,L, ?>,R,F,Either<L,R>>runEitherT() {
21+
returnnewInterpreter<EitherT<F,L, ?>,R,F,Either<L,R>>() {
22+
@Override
23+
public <GBextendsMonadRec<Either<L,R>,F>>GBinterpret(MonadRec<R,EitherT<F,L, ?>>fa) {
24+
returnfa.<EitherT<F,L,R>>coerce().runEitherT();
25+
}
26+
};
27+
}
28+
29+
publicstatic <FextendsMonadRec<?,F>,L,R>Interpreter<EitherT<F,L, ?>,R,F,R>interpretEitherT(
30+
Fn1<?superL, ?extendsR>recoveryFn) {
31+
returnTransformers.<F,L,R>runEitherT().andThen(interpretEither(recoveryFn));
32+
}
33+
34+
35+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<MaybeT<F, ?>,A,F,Maybe<A>>runMaybeT() {
36+
returnnewInterpreter<MaybeT<F, ?>,A,F,Maybe<A>>() {
37+
@Override
38+
public <FMAextendsMonadRec<Maybe<A>,F>>FMAinterpret(MonadRec<A,MaybeT<F, ?>>maybeT) {
39+
returnmaybeT.<MaybeT<F,A>>coerce().runMaybeT();
40+
}
41+
};
42+
}
43+
44+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<MaybeT<F, ?>,A,F,A>interpretMaybeT(Fn0<A>orElse) {
45+
returnTransformers.<F,A>runMaybeT().andThen(interpretMaybe(orElse));
46+
}
47+
48+
49+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<IdentityT<F, ?>,A,F,Identity<A>>runIdentityT() {
50+
returnnewInterpreter<IdentityT<F, ?>,A,F,Identity<A>>() {
51+
@Override
52+
public <GBextendsMonadRec<Identity<A>,F>>GBinterpret(MonadRec<A,IdentityT<F, ?>>fa) {
53+
returnfa.<IdentityT<F,A>>coerce().runIdentityT();
54+
}
55+
};
56+
}
57+
58+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<IdentityT<F, ?>,A,F,A>interpretIdentityT() {
59+
returnTransformers.<F,A>runIdentityT().andThen(interpretIdentity());
60+
}
61+
62+
publicstatic <R,MextendsMonadRec<?,M>>InterpreterH<ReaderT<R,M, ?>,M>runReaderT(Rr) {
63+
returnnewInterpreterH<ReaderT<R,M, ?>,M>() {
64+
@Override
65+
public <A,GAextendsMonadRec<A,M>>GAinterpretH(MonadRec<A,ReaderT<R,M, ?>>fa) {
66+
returnfa.<ReaderT<R,M,A>>coerce().runReaderT(r);
67+
}
68+
};
69+
}
70+
71+
publicstatic <S,MextendsMonadRec<?,M>,A>Interpreter<StateT<S,M, ?>,A,M,Tuple2<A,S>>runStateT(Ss) {
72+
returnnewInterpreter<StateT<S,M, ?>,A,M,Tuple2<A,S>>() {
73+
@Override
74+
public <GBextendsMonadRec<Tuple2<A,S>,M>>GBinterpret(MonadRec<A,StateT<S,M, ?>>fa) {
75+
returnfa.<StateT<S,M,A>>coerce().runStateT(s).coerce();
76+
}
77+
};
78+
}
79+
80+
publicstaticvoidmain(String[]args) {
81+
}
82+
}
Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
packagecom.jnape.palatable.lambda.monad.transformer.interpreter.interpreters;
2+
3+
importcom.jnape.palatable.lambda.adt.Either;
4+
importcom.jnape.palatable.lambda.adt.Maybe;
5+
importcom.jnape.palatable.lambda.adt.hlist.Tuple2;
6+
importcom.jnape.palatable.lambda.functions.Fn0;
7+
importcom.jnape.palatable.lambda.functions.Fn1;
8+
importcom.jnape.palatable.lambda.functor.builtin.Identity;
9+
importcom.jnape.palatable.lambda.functor.builtin.Writer;
10+
importcom.jnape.palatable.lambda.monad.MonadRec;
11+
importcom.jnape.palatable.lambda.monad.transformer.interpreter.Interpreter;
12+
importcom.jnape.palatable.lambda.monoid.Monoid;
13+
14+
publicfinalclassValues {
15+
privateValues() {
16+
}
17+
18+
publicstatic <FextendsMonadRec<?,F>,L,R>Interpreter<F,Either<L,R>,F,R>
19+
interpretEither(Fn1<?superL, ?extendsR>recoveryFn) {
20+
returnnewInterpreter<F,Either<L,R>,F,R>() {
21+
@Override
22+
public <GBextendsMonadRec<R,F>>GBinterpret(MonadRec<Either<L,R>,F>fa) {
23+
returnfa.fmap(lOrR ->lOrR.recover(recoveryFn)).coerce();
24+
}
25+
};
26+
}
27+
28+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<F,Maybe<A>,F,A>interpretMaybe(Fn0<A>orElse) {
29+
returnnewInterpreter<F,Maybe<A>,F,A>() {
30+
@Override
31+
public <GBextendsMonadRec<A,F>>GBinterpret(MonadRec<Maybe<A>,F>fa) {
32+
returnfa.fmap(maybeA ->maybeA.orElseGet(orElse)).coerce();
33+
}
34+
};
35+
}
36+
37+
publicstatic <FextendsMonadRec<?,F>,A>Interpreter<F,Identity<A>,F,A>interpretIdentity() {
38+
returnnewInterpreter<F,Identity<A>,F,A>() {
39+
@Override
40+
public <GBextendsMonadRec<A,F>>GBinterpret(MonadRec<Identity<A>,F>fa) {
41+
returnfa.fmap(Identity::runIdentity).coerce();
42+
}
43+
};
44+
}
45+
46+
publicstatic <FextendsMonadRec<?,F>,W,A>Interpreter<F,Writer<W,A>,F,Tuple2<A,W>>
47+
interpretWriter(Monoid<W>monoidW) {
48+
returnnewInterpreter<F,Writer<W,A>,F,Tuple2<A,W>>() {
49+
@Override
50+
public <GBextendsMonadRec<Tuple2<A,W>,F>>GBinterpret(MonadRec<Writer<W,A>,F>fa) {
51+
returnfa.fmap(writer ->writer.runWriter(monoidW)).coerce();
52+
}
53+
};
54+
}
55+
}

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp