0997883...main · rowtype-yoga/purescript-prospero

.gitignore+1−1

@@ -1,4 +1,4 @@

1−-e output/

1+output/

22node_modules/

33.spago/

44.psc-ide-port

.psc-ide-portdeleted−1

@@ -1 +0,0 @@

1−15825

output-compile-fail/Debug/externs.cbornew file

Binary file not shown.

output-compile-fail/Debug/foreign.jsnew file+57

@@ -0,0 +1,57 @@

1+// Alias require to prevent webpack or browserify from actually requiring.

2+const req = typeof module === "undefined" ? undefined : module.require;

3+const util = (function() {

4+ try {

5+ return req === undefined ? undefined : req("util");

6+ } catch(e) {

7+ return undefined;

8+ }

9+})();

10+

11+export function _trace(x, k) {

12+ // node only recurses two levels into an object before printing

13+ // "[object]" for further objects when using console.log()

14+ if (util !== undefined) {

15+ console.log(util.inspect(x, { depth: null, colors: true }));

16+ } else {

17+ console.log(x);

18+ }

19+ return k({});

20+}

21+

22+export function _spy(tag, x) {

23+ if (util !== undefined) {

24+ console.log(tag + ":", util.inspect(x, { depth: null, colors: true }));

25+ } else {

26+ console.log(tag + ":", x);

27+ }

28+ return x;

29+}

30+

31+export function _debugger(f) {

32+ debugger;

33+ return f();

34+

35+}

36+

37+const now = (function () {

38+ var perf;

39+ if (typeof performance !== "undefined") {

40+ // In browsers, `performance` is available in the global context

41+ perf = performance;

42+ } else if (req) {

43+ // In Node, `performance` is an export of `perf_hooks`

44+ try { perf = req("perf_hooks").performance; }

45+ catch(e) { }

46+ }

47+

48+ return (function() { return (perf || Date).now(); });

49+})();

50+

51+export function _traceTime(name, f) {

52+ var start = now();

53+ var res = f();

54+ var end = now();

55+ console.log(name + " took " + (end - start) + "ms");

56+ return res;

57+}

output-compile-fail/Debug/index.jsnew file+66

@@ -0,0 +1,66 @@

1+// Generated by purs version 0.15.15

2+import * as $foreign from "./foreign.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Control_Bind from "../Control.Bind/index.js";

5+import * as Data_Function from "../Data.Function/index.js";

6+import * as Data_Function_Uncurried from "../Data.Function.Uncurried/index.js";

7+import * as Data_Unit from "../Data.Unit/index.js";

8+var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit);

9+var warn = function () {

10+ return {};

11+};

12+var traceTime = function () {

13+ return Data_Function_Uncurried.runFn2($foreign["_traceTime"]);

14+};

15+var trace = function () {

16+ return function (a) {

17+ return function (k) {

18+ return $foreign["_trace"](a, k);

19+ };

20+ };

21+};

22+var trace1 = /* #__PURE__ */ trace();

23+var traceM = function () {

24+ return function (dictMonad) {

25+ var discard1 = discard(dictMonad.Bind1());

26+ var pure = Control_Applicative.pure(dictMonad.Applicative0());

27+ return function (s) {

28+ return discard1(pure(Data_Unit.unit))(function () {

29+ return trace1(s)(function (v) {

30+ return pure(Data_Unit.unit);

31+ });

32+ });

33+ };

34+ };

35+};

36+var spy = function () {

37+ return function (tag) {

38+ return function (a) {

39+ return $foreign["_spy"](tag, a);

40+ };

41+ };

42+};

43+var spy1 = /* #__PURE__ */ spy();

44+var spyWith = function () {

45+ return function (msg) {

46+ return function (f) {

47+ return function (a) {

48+ return Data_Function["const"](a)(spy1(msg)(f(a)));

49+ };

50+ };

51+ };

52+};

53+var $$debugger = function () {

54+ return function (f) {

55+ return $foreign["_debugger"](f);

56+ };

57+};

58+export {

59+ trace,

60+ traceM,

61+ traceTime,

62+ spy,

63+ spyWith,

64+ $$debugger as debugger,

65+ warn

66+};

output-compile-fail/Dev.Server/index.js+1−1

@@ -26,7 +26,7 @@ var nameIsSymbol = {

2626 return "name";

2727 }

2828};

29−var gqlSchemaArgsCons = /* #__PURE__ */ Prospero_Schema.gqlSchemaArgsCons(nameIsSymbol)(Prospero_InputValue.fromInputValueString)(Prospero_Schema.gqlSchemaStringGqlNonNull)(Prospero_Schema.gqlSchemaArgsNil);

29+var gqlSchemaArgsCons = /* #__PURE__ */ Prospero_Schema.gqlSchemaArgsCons(nameIsSymbol)(Prospero_InputValue.fromInputValueString)(Prospero_Schema.gqlSchemaStringGqlNonNull)(Prospero_Metadata.hasGqlDefaultValue)(Prospero_Schema.gqlSchemaArgsNil);

3030var CharacterIsSymbol = {

3131 reflectSymbol: function () {

3232 return "Character";

output-compile-fail/Dodo.Ansi/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo.Ansi/index.jsnew file+209

@@ -0,0 +1,209 @@

1+// Generated by purs version 0.15.15

2+import * as Ansi_Codes from "../Ansi.Codes/index.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Data_Eq from "../Data.Eq/index.js";

5+import * as Data_Functor from "../Data.Functor/index.js";

6+import * as Data_List from "../Data.List/index.js";

7+import * as Data_List_NonEmpty from "../Data.List.NonEmpty/index.js";

8+import * as Data_List_Types from "../Data.List.Types/index.js";

9+import * as Data_Maybe from "../Data.Maybe/index.js";

10+import * as Dodo from "../Dodo/index.js";

11+var pure = /* #__PURE__ */ Control_Applicative.pure(Data_List_Types.applicativeNonEmptyList);

12+var eq = /* #__PURE__ */ Data_Eq.eq(Ansi_Codes.eqRenderingMode);

13+var notEq = /* #__PURE__ */ Data_Eq.notEq(Ansi_Codes.eqGraphicsParam);

14+var AnsiBuffer = function (x) {

15+ return x;

16+};

17+var underline = /* #__PURE__ */ (function () {

18+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Underline.value));

19+})();

20+var strikethrough = /* #__PURE__ */ (function () {

21+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Strikethrough.value));

22+})();

23+var reset = /* #__PURE__ */ (function () {

24+ return Dodo.annotate(Ansi_Codes.Reset.value);

25+})();

26+var italic = /* #__PURE__ */ (function () {

27+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Italic.value));

28+})();

29+var inverse = /* #__PURE__ */ (function () {

30+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Inverse.value));

31+})();

32+var foreground = function (color) {

33+ return Dodo.annotate(new Ansi_Codes.PForeground(color));

34+};

35+var dim = /* #__PURE__ */ (function () {

36+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Dim.value));

37+})();

38+var bold = /* #__PURE__ */ (function () {

39+ return Dodo.annotate(new Ansi_Codes.PMode(Ansi_Codes.Bold.value));

40+})();

41+var background = function (color) {

42+ return Dodo.annotate(new Ansi_Codes.PBackground(color));

43+};

44+var ansiGraphics = /* #__PURE__ */ (function () {

45+ var writePendingGraphics = function (v) {

46+ if (v.pending instanceof Data_Maybe.Nothing) {

47+ return v;

48+ };

49+ if (v.pending instanceof Data_Maybe.Just) {

50+ return {

51+ current: v.current,

52+ previous: v.previous,

53+ output: v.output + Ansi_Codes.escapeCodeToString(new Ansi_Codes.Graphics(v.pending.value0)),

54+ pending: Data_Maybe.Nothing.value

55+ };

56+ };

57+ throw new Error("Failed pattern match at Dodo.Ansi (line 136, column 5 - line 143, column 12): " + [ v.pending.constructor.name ]);

58+ };

59+ var writeText = function (v) {

60+ return function (text) {

61+ return function (output) {

62+ var v1 = writePendingGraphics(output);

63+ return {

64+ pending: v1.pending,

65+ current: v1.current,

66+ output: v1.output + text,

67+ previous: Data_List_Types.Nil.value

68+ };

69+ };

70+ };

71+ };

72+ var writeIndent = function (v) {

73+ return function (text) {

74+ return function (v1) {

75+ return {

76+ pending: v1.pending,

77+ current: v1.current,

78+ previous: v1.previous,

79+ output: v1.output + text

80+ };

81+ };

82+ };

83+ };

84+ var resetCode = Ansi_Codes.escapeCodeToString(new Ansi_Codes.Graphics(pure(Ansi_Codes.Reset.value)));

85+ var graphicsConflict = function (v) {

86+ return function (v1) {

87+ if (v instanceof Ansi_Codes.Reset && v1 instanceof Ansi_Codes.Reset) {

88+ return true;

89+ };

90+ if (v instanceof Ansi_Codes.PForeground && v1 instanceof Ansi_Codes.PForeground) {

91+ return true;

92+ };

93+ if (v instanceof Ansi_Codes.PBackground && v1 instanceof Ansi_Codes.PBackground) {

94+ return true;

95+ };

96+ if (v instanceof Ansi_Codes.PMode && v1 instanceof Ansi_Codes.PMode) {

97+ return eq(v.value0)(v1.value0);

98+ };

99+ return false;

100+ };

101+ };

102+ var getPendingGraphics = (function () {

103+ var $50 = Data_Functor.map(Data_Maybe.functorMaybe)(Data_List_NonEmpty.cons(Ansi_Codes.Reset.value));

104+ return function ($51) {

105+ return $50(Data_List_NonEmpty.fromList($51));

106+ };

107+ })();

108+ var writeBreak = function (v) {

109+ var pending = getPendingGraphics(v.current);

110+ var resetOrEmpty = (function () {

111+ var $42 = Data_Maybe.isNothing(pending) && Data_List["null"](v.previous);

112+ if ($42) {

113+ return "";

114+ };

115+ return resetCode;

116+ })();

117+ return {

118+ current: v.current,

119+ previous: v.previous,

120+ output: v.output + (resetOrEmpty + "\x0a"),

121+ pending: pending

122+ };

123+ };

124+ var getCurrentGraphics = (function () {

125+ var $52 = Data_List.nubByEq(graphicsConflict);

126+ var $53 = Data_List.takeWhile(function (v) {

127+ return notEq(v)(Ansi_Codes.Reset.value);

128+ });

129+ return function ($54) {

130+ return Data_List.reverse($52($53($54)));

131+ };

132+ })();

133+ var leaveAnnotation = function (v) {

134+ return function (as) {

135+ return function (v1) {

136+ var current = getCurrentGraphics(as);

137+ return {

138+ output: v1.output,

139+ pending: new Data_Maybe.Just(Data_Maybe.fromMaybe(pure(Ansi_Codes.Reset.value))(getPendingGraphics(current))),

140+ current: current,

141+ previous: v1.current

142+ };

143+ };

144+ };

145+ };

146+ var flushBuffer = function (ansiBuffer) {

147+ var v = writePendingGraphics(ansiBuffer);

148+ return v.output;

149+ };

150+ var enterAnnotation = function (a) {

151+ return function (as) {

152+ return function (v) {

153+ var current = getCurrentGraphics(new Data_List_Types.Cons(a, as));

154+ return {

155+ output: v.output,

156+ pending: getPendingGraphics(current),

157+ current: current,

158+ previous: v.current

159+ };

160+ };

161+ };

162+ };

163+ var emptyBuffer = {

164+ output: "",

165+ pending: Data_Maybe.Nothing.value,

166+ current: Data_List_Types.Nil.value,

167+ previous: Data_List_Types.Nil.value

168+ };

169+ return {

170+ emptyBuffer: emptyBuffer,

171+ writeText: writeText,

172+ writeIndent: writeIndent,

173+ writeBreak: writeBreak,

174+ enterAnnotation: enterAnnotation,

175+ leaveAnnotation: leaveAnnotation,

176+ flushBuffer: flushBuffer

177+ };

178+})();

179+export {

180+ AnsiBuffer,

181+ ansiGraphics,

182+ background,

183+ bold,

184+ dim,

185+ foreground,

186+ inverse,

187+ italic,

188+ reset,

189+ strikethrough,

190+ underline

191+};

192+export {

193+ Black,

194+ Blue,

195+ BrightBlack,

196+ BrightBlue,

197+ BrightCyan,

198+ BrightGreen,

199+ BrightMagenta,

200+ BrightRed,

201+ BrightWhite,

202+ BrightYellow,

203+ Cyan,

204+ Green,

205+ Magenta,

206+ Red,

207+ White,

208+ Yellow

209+} from "../Ansi.Codes/index.js";

output-compile-fail/Dodo.Box/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo.Box/index.jsnew file+1126

@@ -0,0 +1,1126 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Boolean from "../Data.Boolean/index.js";

3+import * as Data_Either from "../Data.Either/index.js";

4+import * as Data_Foldable from "../Data.Foldable/index.js";

5+import * as Data_Function from "../Data.Function/index.js";

6+import * as Data_Functor from "../Data.Functor/index.js";

7+import * as Data_Int from "../Data.Int/index.js";

8+import * as Data_List from "../Data.List/index.js";

9+import * as Data_List_Types from "../Data.List.Types/index.js";

10+import * as Data_Maybe from "../Data.Maybe/index.js";

11+import * as Data_Monoid from "../Data.Monoid/index.js";

12+import * as Data_Newtype from "../Data.Newtype/index.js";

13+import * as Data_Ord from "../Data.Ord/index.js";

14+import * as Data_Semigroup from "../Data.Semigroup/index.js";

15+import * as Dodo from "../Dodo/index.js";

16+import * as Dodo_Internal from "../Dodo.Internal/index.js";

17+import * as Partial_Unsafe from "../Partial.Unsafe/index.js";

18+import * as Safe_Coerce from "../Safe.Coerce/index.js";

19+var map = /* #__PURE__ */ Data_Functor.map(Dodo_Internal.functorDoc);

20+var max = /* #__PURE__ */ Data_Ord.max(Data_Ord.ordInt);

21+var coerce = /* #__PURE__ */ Safe_Coerce.coerce();

22+var append = /* #__PURE__ */ Data_Semigroup.append(Dodo_Internal.semigroupDoc);

23+var power = /* #__PURE__ */ Data_Monoid.power(Dodo_Internal.monoidDoc);

24+var mempty = /* #__PURE__ */ Data_Monoid.mempty(Dodo_Internal.monoidDoc);

25+var under = /* #__PURE__ */ Data_Newtype.under()();

26+var LinePad = /* #__PURE__ */ (function () {

27+ function LinePad(value0) {

28+ this.value0 = value0;

29+ };

30+ LinePad.create = function (value0) {

31+ return new LinePad(value0);

32+ };

33+ return LinePad;

34+})();

35+var LineDoc = /* #__PURE__ */ (function () {

36+ function LineDoc(value0) {

37+ this.value0 = value0;

38+ };

39+ LineDoc.create = function (value0) {

40+ return new LineDoc(value0);

41+ };

42+ return LineDoc;

43+})();

44+var LineAppend = /* #__PURE__ */ (function () {

45+ function LineAppend(value0, value1) {

46+ this.value0 = value0;

47+ this.value1 = value1;

48+ };

49+ LineAppend.create = function (value0) {

50+ return function (value1) {

51+ return new LineAppend(value0, value1);

52+ };

53+ };

54+ return LineAppend;

55+})();

56+var FullHeight = /* #__PURE__ */ (function () {

57+ function FullHeight(value0) {

58+ this.value0 = value0;

59+ };

60+ FullHeight.create = function (value0) {

61+ return new FullHeight(value0);

62+ };

63+ return FullHeight;

64+})();

65+var FullWidth = /* #__PURE__ */ (function () {

66+ function FullWidth(value0) {

67+ this.value0 = value0;

68+ };

69+ FullWidth.create = function (value0) {

70+ return new FullWidth(value0);

71+ };

72+ return FullWidth;

73+})();

74+var AsIs = /* #__PURE__ */ (function () {

75+ function AsIs() {

76+

77+ };

78+ AsIs.value = new AsIs();

79+ return AsIs;

80+})();

81+var StpDone = /* #__PURE__ */ (function () {

82+ function StpDone() {

83+

84+ };

85+ StpDone.value = new StpDone();

86+ return StpDone;

87+})();

88+var StpLine = /* #__PURE__ */ (function () {

89+ function StpLine(value0, value1) {

90+ this.value0 = value0;

91+ this.value1 = value1;

92+ };

93+ StpLine.create = function (value0) {

94+ return function (value1) {

95+ return new StpLine(value0, value1);

96+ };

97+ };

98+ return StpLine;

99+})();

100+var StpPad = /* #__PURE__ */ (function () {

101+ function StpPad(value0, value1, value2) {

102+ this.value0 = value0;

103+ this.value1 = value1;

104+ this.value2 = value2;

105+ };

106+ StpPad.create = function (value0) {

107+ return function (value1) {

108+ return function (value2) {

109+ return new StpPad(value0, value1, value2);

110+ };

111+ };

112+ };

113+ return StpPad;

114+})();

115+var StpHorz = /* #__PURE__ */ (function () {

116+ function StpHorz(value0, value1, value2) {

117+ this.value0 = value0;

118+ this.value1 = value1;

119+ this.value2 = value2;

120+ };

121+ StpHorz.create = function (value0) {

122+ return function (value1) {

123+ return function (value2) {

124+ return new StpHorz(value0, value1, value2);

125+ };

126+ };

127+ };

128+ return StpHorz;

129+})();

130+var ResumeEnter = /* #__PURE__ */ (function () {

131+ function ResumeEnter(value0) {

132+ this.value0 = value0;

133+ };

134+ ResumeEnter.create = function (value0) {

135+ return new ResumeEnter(value0);

136+ };

137+ return ResumeEnter;

138+})();

139+var ResumeLeave = /* #__PURE__ */ (function () {

140+ function ResumeLeave(value0) {

141+ this.value0 = value0;

142+ };

143+ ResumeLeave.create = function (value0) {

144+ return new ResumeLeave(value0);

145+ };

146+ return ResumeLeave;

147+})();

148+var ResumeHorzR = /* #__PURE__ */ (function () {

149+ function ResumeHorzR(value0, value1, value2) {

150+ this.value0 = value0;

151+ this.value1 = value1;

152+ this.value2 = value2;

153+ };

154+ ResumeHorzR.create = function (value0) {

155+ return function (value1) {

156+ return function (value2) {

157+ return new ResumeHorzR(value0, value1, value2);

158+ };

159+ };

160+ };

161+ return ResumeHorzR;

162+})();

163+var ResumeHorzH = /* #__PURE__ */ (function () {

164+ function ResumeHorzH(value0, value1, value2) {

165+ this.value0 = value0;

166+ this.value1 = value1;

167+ this.value2 = value2;

168+ };

169+ ResumeHorzH.create = function (value0) {

170+ return function (value1) {

171+ return function (value2) {

172+ return new ResumeHorzH(value0, value1, value2);

173+ };

174+ };

175+ };

176+ return ResumeHorzH;

177+})();

178+var ResumeNil = /* #__PURE__ */ (function () {

179+ function ResumeNil() {

180+

181+ };

182+ ResumeNil.value = new ResumeNil();

183+ return ResumeNil;

184+})();

185+var Start = /* #__PURE__ */ (function () {

186+ function Start() {

187+

188+ };

189+ Start.value = new Start();

190+ return Start;

191+})();

192+var Middle = /* #__PURE__ */ (function () {

193+ function Middle() {

194+

195+ };

196+ Middle.value = new Middle();

197+ return Middle;

198+})();

199+var End = /* #__PURE__ */ (function () {

200+ function End() {

201+

202+ };

203+ End.value = new End();

204+ return End;

205+})();

206+var DocLine = /* #__PURE__ */ (function () {

207+ function DocLine(value0, value1) {

208+ this.value0 = value0;

209+ this.value1 = value1;

210+ };

211+ DocLine.create = function (value0) {

212+ return function (value1) {

213+ return new DocLine(value0, value1);

214+ };

215+ };

216+ return DocLine;

217+})();

218+var DocVApp = /* #__PURE__ */ (function () {

219+ function DocVApp(value0, value1, value2) {

220+ this.value0 = value0;

221+ this.value1 = value1;

222+ this.value2 = value2;

223+ };

224+ DocVApp.create = function (value0) {

225+ return function (value1) {

226+ return function (value2) {

227+ return new DocVApp(value0, value1, value2);

228+ };

229+ };

230+ };

231+ return DocVApp;

232+})();

233+var DocHApp = /* #__PURE__ */ (function () {

234+ function DocHApp(value0, value1, value2) {

235+ this.value0 = value0;

236+ this.value1 = value1;

237+ this.value2 = value2;

238+ };

239+ DocHApp.create = function (value0) {

240+ return function (value1) {

241+ return function (value2) {

242+ return new DocHApp(value0, value1, value2);

243+ };

244+ };

245+ };

246+ return DocHApp;

247+})();

248+var DocAlign = /* #__PURE__ */ (function () {

249+ function DocAlign(value0, value1, value2) {

250+ this.value0 = value0;

251+ this.value1 = value1;

252+ this.value2 = value2;

253+ };

254+ DocAlign.create = function (value0) {

255+ return function (value1) {

256+ return function (value2) {

257+ return new DocAlign(value0, value1, value2);

258+ };

259+ };

260+ };

261+ return DocAlign;

262+})();

263+var DocPad = /* #__PURE__ */ (function () {

264+ function DocPad(value0) {

265+ this.value0 = value0;

266+ };

267+ DocPad.create = function (value0) {

268+ return new DocPad(value0);

269+ };

270+ return DocPad;

271+})();

272+var DocEmpty = /* #__PURE__ */ (function () {

273+ function DocEmpty() {

274+

275+ };

276+ DocEmpty.value = new DocEmpty();

277+ return DocEmpty;

278+})();

279+var DocBoxBuffer = function (x) {

280+ return x;

281+};

282+var BuildEnter = /* #__PURE__ */ (function () {

283+ function BuildEnter(value0, value1, value2) {

284+ this.value0 = value0;

285+ this.value1 = value1;

286+ this.value2 = value2;

287+ };

288+ BuildEnter.create = function (value0) {

289+ return function (value1) {

290+ return function (value2) {

291+ return new BuildEnter(value0, value1, value2);

292+ };

293+ };

294+ };

295+ return BuildEnter;

296+})();

297+var BuildLeave = /* #__PURE__ */ (function () {

298+ function BuildLeave(value0) {

299+ this.value0 = value0;

300+ };

301+ BuildLeave.create = function (value0) {

302+ return new BuildLeave(value0);

303+ };

304+ return BuildLeave;

305+})();

306+var BuildVAppR = /* #__PURE__ */ (function () {

307+ function BuildVAppR(value0, value1, value2) {

308+ this.value0 = value0;

309+ this.value1 = value1;

310+ this.value2 = value2;

311+ };

312+ BuildVAppR.create = function (value0) {

313+ return function (value1) {

314+ return function (value2) {

315+ return new BuildVAppR(value0, value1, value2);

316+ };

317+ };

318+ };

319+ return BuildVAppR;

320+})();

321+var BuildHAppR = /* #__PURE__ */ (function () {

322+ function BuildHAppR(value0, value1, value2, value3) {

323+ this.value0 = value0;

324+ this.value1 = value1;

325+ this.value2 = value2;

326+ this.value3 = value3;

327+ };

328+ BuildHAppR.create = function (value0) {

329+ return function (value1) {

330+ return function (value2) {

331+ return function (value3) {

332+ return new BuildHAppR(value0, value1, value2, value3);

333+ };

334+ };

335+ };

336+ };

337+ return BuildHAppR;

338+})();

339+var BuildHAppH = /* #__PURE__ */ (function () {

340+ function BuildHAppH(value0, value1, value2) {

341+ this.value0 = value0;

342+ this.value1 = value1;

343+ this.value2 = value2;

344+ };

345+ BuildHAppH.create = function (value0) {

346+ return function (value1) {

347+ return function (value2) {

348+ return new BuildHAppH(value0, value1, value2);

349+ };

350+ };

351+ };

352+ return BuildHAppH;

353+})();

354+var BuildNil = /* #__PURE__ */ (function () {

355+ function BuildNil() {

356+

357+ };

358+ BuildNil.value = new BuildNil();

359+ return BuildNil;

360+})();

361+var Horizontal = function (x) {

362+ return x;

363+};

364+var Vertical = function (x) {

365+ return x;

366+};

367+var newtypeVertical_ = {

368+ Coercible0: function () {

369+ return undefined;

370+ }

371+};

372+var newtypeHorizontal_ = {

373+ Coercible0: function () {

374+ return undefined;

375+ }

376+};

377+var functorDocBox = {

378+ map: function (f) {

379+ return function (m) {

380+ if (m instanceof DocLine) {

381+ return new DocLine(map(f)(m.value0), m.value1);

382+ };

383+ if (m instanceof DocVApp) {

384+ return new DocVApp(Data_Functor.map(functorDocBox)(f)(m.value0), Data_Functor.map(functorDocBox)(f)(m.value1), m.value2);

385+ };

386+ if (m instanceof DocHApp) {

387+ return new DocHApp(Data_Functor.map(functorDocBox)(f)(m.value0), Data_Functor.map(functorDocBox)(f)(m.value1), m.value2);

388+ };

389+ if (m instanceof DocAlign) {

390+ return new DocAlign(m.value0, m.value1, Data_Functor.map(functorDocBox)(f)(m.value2));

391+ };

392+ if (m instanceof DocPad) {

393+ return new DocPad(m.value0);

394+ };

395+ if (m instanceof DocEmpty) {

396+ return DocEmpty.value;

397+ };

398+ throw new Error("Failed pattern match at Dodo.Box (line 0, column 0 - line 0, column 0): " + [ m.constructor.name ]);

399+ };

400+ }

401+};

402+var functorHorizontal = functorDocBox;

403+var functorVertical = functorDocBox;

404+var eqAlign = {

405+ eq: function (x) {

406+ return function (y) {

407+ if (x instanceof Start && y instanceof Start) {

408+ return true;

409+ };

410+ if (x instanceof Middle && y instanceof Middle) {

411+ return true;

412+ };

413+ if (x instanceof End && y instanceof End) {

414+ return true;

415+ };

416+ return false;

417+ };

418+ }

419+};

420+var vpadding = function (height) {

421+ if (height <= 0) {

422+ return DocEmpty.value;

423+ };

424+ if (Data_Boolean.otherwise) {

425+ return new DocPad({

426+ height: height,

427+ width: 0

428+ });

429+ };

430+ throw new Error("Failed pattern match at Dodo.Box (line 228, column 1 - line 228, column 38): " + [ height.constructor.name ]);

431+};

432+var valignOf = function (v) {

433+ if (v instanceof DocAlign) {

434+ return v.value0;

435+ };

436+ return Start.value;

437+};

438+var valign = function (a) {

439+ return function (v) {

440+ var v1 = function (v2) {

441+ if (v instanceof DocAlign && Data_Boolean.otherwise) {

442+ return new DocAlign(a, v.value1, v.value2);

443+ };

444+ return new DocAlign(a, Start.value, v);

445+ };

446+ if (v instanceof DocAlign) {

447+ if (a instanceof Start) {

448+ if (v.value1 instanceof Start) {

449+ return v.value2;

450+ };

451+ return v1(true);

452+ };

453+ return v1(true);

454+ };

455+ return v1(true);

456+ };

457+};

458+var sizeOf = function ($copy_v) {

459+ var $tco_done = false;

460+ var $tco_result;

461+ function $tco_loop(v) {

462+ if (v instanceof DocLine) {

463+ $tco_done = true;

464+ return {

465+ width: v.value1,

466+ height: 1

467+ };

468+ };

469+ if (v instanceof DocVApp) {

470+ $tco_done = true;

471+ return v.value2;

472+ };

473+ if (v instanceof DocHApp) {

474+ $tco_done = true;

475+ return v.value2;

476+ };

477+ if (v instanceof DocAlign) {

478+ $copy_v = v.value2;

479+ return;

480+ };

481+ if (v instanceof DocPad) {

482+ $tco_done = true;

483+ return v.value0;

484+ };

485+ if (v instanceof DocEmpty) {

486+ $tco_done = true;

487+ return {

488+ width: 0,

489+ height: 0

490+ };

491+ };

492+ throw new Error("Failed pattern match at Dodo.Box (line 241, column 10 - line 247, column 38): " + [ v.constructor.name ]);

493+ };

494+ while (!$tco_done) {

495+ $tco_result = $tco_loop($copy_v);

496+ };

497+ return $tco_result;

498+};

499+var vappend = /* #__PURE__ */ (function () {

500+ var scale = function (sizea) {

501+ return function (sizeb) {

502+ return {

503+ width: max(sizea.width)(sizeb.width),

504+ height: sizea.height + sizeb.height | 0

505+ };

506+ };

507+ };

508+ return function (v) {

509+ return function (v1) {

510+ if (v instanceof DocEmpty) {

511+ return v1;

512+ };

513+ if (v1 instanceof DocEmpty) {

514+ return v;

515+ };

516+ if (v instanceof DocPad && v1 instanceof DocPad) {

517+ return new DocPad(scale(v.value0)(v1.value0));

518+ };

519+ return new DocVApp(v, v1, scale(sizeOf(v))(sizeOf(v1)));

520+ };

521+ };

522+})();

523+var vertical = function (dictFoldable) {

524+ return Data_Foldable.foldr(dictFoldable)(vappend)(DocEmpty.value);

525+};

526+var semigroupVertical = {

527+ append: /* #__PURE__ */ coerce(vappend)

528+};

529+var monoidVertical = /* #__PURE__ */ (function () {

530+ return {

531+ mempty: DocEmpty.value,

532+ Semigroup0: function () {

533+ return semigroupVertical;

534+ }

535+ };

536+})();

537+var power1 = /* #__PURE__ */ Data_Monoid.power(monoidVertical);

538+var resume = /* #__PURE__ */ (function () {

539+ var go = function ($copy_cmd) {

540+ return function ($copy_stack) {

541+ var $tco_var_cmd = $copy_cmd;

542+ var $tco_done = false;

543+ var $tco_result;

544+ function $tco_loop(cmd, stack) {

545+ if (cmd instanceof ResumeEnter) {

546+ if (cmd.value0 instanceof StpDone) {

547+ $tco_var_cmd = new ResumeLeave(Data_Maybe.Nothing.value);

548+ $copy_stack = stack;

549+ return;

550+ };

551+ if (cmd.value0 instanceof StpLine) {

552+ $tco_var_cmd = new ResumeLeave(new Data_Maybe.Just({

553+ line: new LineDoc(cmd.value0.value0),

554+ next: cmd.value0.value1

555+ }));

556+ $copy_stack = stack;

557+ return;

558+ };

559+ if (cmd.value0 instanceof StpPad) {

560+ var $136 = cmd.value0.value1 === 0;

561+ if ($136) {

562+ $tco_var_cmd = new ResumeEnter(cmd.value0.value2);

563+ $copy_stack = stack;

564+ return;

565+ };

566+ $tco_var_cmd = new ResumeLeave(new Data_Maybe.Just({

567+ line: new LinePad(cmd.value0.value0),

568+ next: new StpPad(cmd.value0.value0, cmd.value0.value1 - 1 | 0, cmd.value0.value2)

569+ }));

570+ $copy_stack = stack;

571+ return;

572+ };

573+ if (cmd.value0 instanceof StpHorz) {

574+ $tco_var_cmd = new ResumeEnter(cmd.value0.value1);

575+ $copy_stack = new ResumeHorzR(cmd.value0.value0, cmd.value0.value2, stack);

576+ return;

577+ };

578+ throw new Error("Failed pattern match at Dodo.Box (line 389, column 7 - line 406, column 56): " + [ cmd.value0.constructor.name ]);

579+ };

580+ if (cmd instanceof ResumeLeave) {

581+ if (stack instanceof ResumeHorzR) {

582+ $tco_var_cmd = new ResumeEnter(stack.value0);

583+ $copy_stack = new ResumeHorzH(cmd.value0, stack.value1, stack.value2);

584+ return;

585+ };

586+ if (stack instanceof ResumeHorzH) {

587+ if (cmd.value0 instanceof Data_Maybe.Just && stack.value0 instanceof Data_Maybe.Just) {

588+ $tco_var_cmd = new ResumeLeave(new Data_Maybe.Just({

589+ line: new LineAppend(cmd.value0.value0.line, stack.value0.value0.line),

590+ next: new StpHorz(cmd.value0.value0.next, stack.value0.value0.next, stack.value1)

591+ }));

592+ $copy_stack = stack.value2;

593+ return;

594+ };

595+ $tco_var_cmd = new ResumeEnter(stack.value1);

596+ $copy_stack = stack.value2;

597+ return;

598+ };

599+ if (stack instanceof ResumeNil) {

600+ $tco_done = true;

601+ return cmd.value0;

602+ };

603+ throw new Error("Failed pattern match at Dodo.Box (line 408, column 7 - line 424, column 15): " + [ stack.constructor.name ]);

604+ };

605+ throw new Error("Failed pattern match at Dodo.Box (line 387, column 18 - line 424, column 15): " + [ cmd.constructor.name ]);

606+ };

607+ while (!$tco_done) {

608+ $tco_result = $tco_loop($tco_var_cmd, $copy_stack);

609+ };

610+ return $tco_result;

611+ };

612+ };

613+ var $277 = Data_Function.flip(go)(ResumeNil.value);

614+ return function ($278) {

615+ return $277(ResumeEnter.create($278));

616+ };

617+})();

618+var padWithAlign = function (appendFn) {

619+ return function (paddingFn) {

620+ return function (padWidth) {

621+ return function (doc) {

622+ return function (v) {

623+ if (v instanceof Start) {

624+ return appendFn(doc)(paddingFn(padWidth));

625+ };

626+ if (v instanceof Middle) {

627+ var mid = Data_Int.toNumber(padWidth) / 2.0;

628+ return appendFn(appendFn(paddingFn(Data_Int.floor(mid)))(doc))(paddingFn(Data_Int.ceil(mid)));

629+ };

630+ if (v instanceof End) {

631+ return appendFn(paddingFn(padWidth))(doc);

632+ };

633+ throw new Error("Failed pattern match at Dodo.Box (line 197, column 48 - line 206, column 38): " + [ v.constructor.name ]);

634+ };

635+ };

636+ };

637+ };

638+};

639+var isEmpty = function (v) {

640+ if (v instanceof DocEmpty) {

641+ return true;

642+ };

643+ return false;

644+};

645+var hpadding = function (width) {

646+ if (width <= 0) {

647+ return DocEmpty.value;

648+ };

649+ if (Data_Boolean.otherwise) {

650+ return new DocPad({

651+ height: 1,

652+ width: width

653+ });

654+ };

655+ throw new Error("Failed pattern match at Dodo.Box (line 234, column 1 - line 234, column 38): " + [ width.constructor.name ]);

656+};

657+var happend = /* #__PURE__ */ (function () {

658+ var scale = function (sizea) {

659+ return function (sizeb) {

660+ return {

661+ width: sizea.width + sizeb.width | 0,

662+ height: max(sizea.height)(sizeb.height)

663+ };

664+ };

665+ };

666+ return function (v) {

667+ return function (v1) {

668+ if (v instanceof DocEmpty) {

669+ return v1;

670+ };

671+ if (v1 instanceof DocEmpty) {

672+ return v;

673+ };

674+ if (v instanceof DocPad && v1 instanceof DocPad) {

675+ return new DocPad(scale(v.value0)(v1.value0));

676+ };

677+ return new DocHApp(v, v1, scale(sizeOf(v))(sizeOf(v1)));

678+ };

679+ };

680+})();

681+var horizontal = function (dictFoldable) {

682+ return Data_Foldable.foldr(dictFoldable)(happend)(DocEmpty.value);

683+};

684+var horizontalWithAlign = function (dictFoldable) {

685+ var foldr = Data_Foldable.foldr(dictFoldable);

686+ return function (align) {

687+ return foldr(function (a) {

688+ return function (b) {

689+ return happend(valign(align)(a))(b);

690+ };

691+ })(DocEmpty.value);

692+ };

693+};

694+var semigroupHorizontal = {

695+ append: /* #__PURE__ */ coerce(happend)

696+};

697+var monoidHorizontal = /* #__PURE__ */ (function () {

698+ return {

699+ mempty: DocEmpty.value,

700+ Semigroup0: function () {

701+ return semigroupHorizontal;

702+ }

703+ };

704+})();

705+var halignOf = function (v) {

706+ if (v instanceof DocAlign) {

707+ return v.value1;

708+ };

709+ return Start.value;

710+};

711+var halign = function (b) {

712+ return function (v) {

713+ var v1 = function (v2) {

714+ if (v instanceof DocAlign && Data_Boolean.otherwise) {

715+ return new DocAlign(v.value0, b, v.value2);

716+ };

717+ return new DocAlign(Start.value, b, v);

718+ };

719+ if (v instanceof DocAlign) {

720+ if (v.value0 instanceof Start) {

721+ if (b instanceof Start) {

722+ return v.value2;

723+ };

724+ return v1(true);

725+ };

726+ return v1(true);

727+ };

728+ return v1(true);

729+ };

730+};

731+var resize = function (newSize) {

732+ return function (box) {

733+ var size = sizeOf(box);

734+ var vpad = newSize.height - size.height | 0;

735+ var hpad = newSize.width - size.width | 0;

736+ var box$prime = (function () {

737+ if (box instanceof DocAlign) {

738+ return box.value2;

739+ };

740+ return box;

741+ })();

742+ var hdoc = (function () {

743+ if (hpad <= 0) {

744+ return valign(Start.value)(box$prime);

745+ };

746+ if (Data_Boolean.otherwise) {

747+ return padWithAlign(happend)(hpadding)(hpad)(box)(halignOf(box));

748+ };

749+ throw new Error("Failed pattern match at Dodo.Box (line 189, column 3 - line 191, column 72): " + [ ]);

750+ })();

751+ var vdoc = (function () {

752+ if (vpad <= 0) {

753+ return halign(Start.value)(hdoc);

754+ };

755+ if (Data_Boolean.otherwise) {

756+ return padWithAlign(vappend)(vpadding)(vpad)(hdoc)(valignOf(box));

757+ };

758+ throw new Error("Failed pattern match at Dodo.Box (line 192, column 3 - line 194, column 73): " + [ ]);

759+ })();

760+ return vdoc;

761+ };

762+};

763+var verticalWithAlign = function (dictFoldable) {

764+ var foldr = Data_Foldable.foldr(dictFoldable);

765+ return function (align) {

766+ return foldr(function (a) {

767+ return function (b) {

768+ return vappend(halign(align)(a))(b);

769+ };

770+ })(DocEmpty.value);

771+ };

772+};

773+var formatLine = /* #__PURE__ */ (function () {

774+ var go = function ($copy_acc) {

775+ return function ($copy_v) {

776+ var $tco_var_acc = $copy_acc;

777+ var $tco_done = false;

778+ var $tco_result;

779+ function $tco_loop(acc, v) {

780+ if (v instanceof Data_List_Types.Nil) {

781+ $tco_done = true;

782+ return acc;

783+ };

784+ if (v instanceof Data_List_Types.Cons) {

785+ if (v.value0 instanceof LinePad) {

786+ if (Dodo_Internal.isEmpty(acc)) {

787+ $tco_var_acc = acc;

788+ $copy_v = v.value1;

789+ return;

790+ };

791+ if (Data_Boolean.otherwise) {

792+ $tco_var_acc = append(power(Dodo.space)(v.value0.value0))(acc);

793+ $copy_v = v.value1;

794+ return;

795+ };

796+ };

797+ if (v.value0 instanceof LineDoc) {

798+ $tco_var_acc = append(v.value0.value0)(acc);

799+ $copy_v = v.value1;

800+ return;

801+ };

802+ if (v.value0 instanceof LineAppend) {

803+ $tco_var_acc = acc;

804+ $copy_v = new Data_List_Types.Cons(v.value0.value1, new Data_List_Types.Cons(v.value0.value0, v.value1));

805+ return;

806+ };

807+ throw new Error("Failed pattern match at Dodo.Box (line 290, column 7 - line 299, column 33): " + [ v.value0.constructor.name ]);

808+ };

809+ throw new Error("Failed pattern match at Dodo.Box (line 286, column 12 - line 299, column 33): " + [ v.constructor.name ]);

810+ };

811+ while (!$tco_done) {

812+ $tco_result = $tco_loop($tco_var_acc, $copy_v);

813+ };

814+ return $tco_result;

815+ };

816+ };

817+ var $279 = go(mempty);

818+ return function ($280) {

819+ return $279(Data_List.singleton($280));

820+ };

821+})();

822+var fill = function (ch) {

823+ return function (v) {

824+ var line = (function () {

825+ if (ch instanceof Dodo_Internal.Annotate) {

826+ return new DocLine(Dodo.annotate(ch.value0)(power(ch.value1)(v.width)), v.width);

827+ };

828+ return new DocLine(power(ch)(v.width), v.width);

829+ })();

830+ return under(Vertical)(Data_Function.flip(power1)(v.height))(line);

831+ };

832+};

833+var empty = /* #__PURE__ */ (function () {

834+ return DocEmpty.value;

835+})();

836+var docBox = /* #__PURE__ */ (function () {

837+ var writeText = function (width) {

838+ return function (text) {

839+ return function (v) {

840+ var doc$prime = new Dodo_Internal.Text(width, text);

841+ var line = (function () {

842+ if (v.currentLine instanceof Data_List_Types.Cons && v.currentLine.value0 instanceof Data_Either.Right) {

843+ return new Data_List_Types.Cons(new Data_Either.Right(append(v.currentLine.value0.value0)(doc$prime)), v.currentLine.value1);

844+ };

845+ return new Data_List_Types.Cons(new Data_Either.Right(doc$prime), v.currentLine);

846+ })();

847+ return {

848+ currentIndent: v.currentIndent,

849+ lines: v.lines,

850+ currentLine: line,

851+ currentWidth: v.currentWidth + width | 0

852+ };

853+ };

854+ };

855+ };

856+ var writeIndent = function (width) {

857+ return function (text) {

858+ return function (v) {

859+ var doc = new Dodo_Internal.Text(width, text);

860+ return {

861+ currentLine: v.currentLine,

862+ lines: v.lines,

863+ currentIndent: append(v.currentIndent)(doc),

864+ currentWidth: v.currentWidth + width | 0

865+ };

866+ };

867+ };

868+ };

869+ var stkToDoc = Data_Foldable.foldl(Data_List_Types.foldableList)(function (doc) {

870+ return function (v) {

871+ if (v instanceof Data_Either.Left) {

872+ return Dodo.annotate(v.value0)(doc);

873+ };

874+ if (v instanceof Data_Either.Right) {

875+ return append(v.value0)(doc);

876+ };

877+ throw new Error("Failed pattern match at Dodo.Box (line 521, column 15 - line 525, column 22): " + [ v.constructor.name ]);

878+ };

879+ })(mempty);

880+ var writeBreak = function (v) {

881+ var line = stkToDoc(v.currentLine);

882+ return {

883+ currentIndent: mempty,

884+ currentLine: Data_List.filter(Data_Either.isLeft)(v.currentLine),

885+ currentWidth: 0,

886+ lines: vappend(v.lines)(new DocLine(append(v.currentIndent)(line), v.currentWidth))

887+ };

888+ };

889+ var leaveAnnotation = function (v) {

890+ return function (v1) {

891+ return function (v2) {

892+ var line = (function () {

893+ if (v2.currentLine instanceof Data_List_Types.Cons && (v2.currentLine.value0 instanceof Data_Either.Right && (v2.currentLine.value1 instanceof Data_List_Types.Cons && v2.currentLine.value1.value0 instanceof Data_Either.Left))) {

894+ return new Data_List_Types.Cons(new Data_Either.Right(Dodo.annotate(v2.currentLine.value1.value0.value0)(v2.currentLine.value0.value0)), v2.currentLine.value1.value1);

895+ };

896+ if (v2.currentLine instanceof Data_List_Types.Cons && v2.currentLine.value0 instanceof Data_Either.Left) {

897+ return v2.currentLine.value1;

898+ };

899+ return Partial_Unsafe.unsafeCrashWith("leaveAnnotation: docs and annotations must be interleaved");

900+ })();

901+ return {

902+ currentIndent: v2.currentIndent,

903+ currentWidth: v2.currentWidth,

904+ lines: v2.lines,

905+ currentLine: line

906+ };

907+ };

908+ };

909+ };

910+ var flushBuffer = function (v) {

911+ if (isEmpty(v.lines) && Data_List["null"](v.currentLine)) {

912+ return DocEmpty.value;

913+ };

914+ if (Data_Boolean.otherwise) {

915+ var line = stkToDoc(v.currentLine);

916+ return vappend(v.lines)(new DocLine(append(v.currentIndent)(line), v.currentWidth));

917+ };

918+ throw new Error("Failed pattern match at Dodo.Box (line 511, column 3 - line 511, column 44): " + [ v.constructor.name ]);

919+ };

920+ var enterAnnotation = function (ann) {

921+ return function (v) {

922+ return function (v1) {

923+ return {

924+ currentIndent: v1.currentIndent,

925+ currentWidth: v1.currentWidth,

926+ lines: v1.lines,

927+ currentLine: new Data_List_Types.Cons(new Data_Either.Left(ann), v1.currentLine)

928+ };

929+ };

930+ };

931+ };

932+ var emptyBuffer = {

933+ currentIndent: mempty,

934+ currentLine: Data_List_Types.Nil.value,

935+ currentWidth: 0,

936+ lines: DocEmpty.value

937+ };

938+ return {

939+ emptyBuffer: emptyBuffer,

940+ writeText: writeText,

941+ writeIndent: writeIndent,

942+ writeBreak: writeBreak,

943+ enterAnnotation: enterAnnotation,

944+ leaveAnnotation: leaveAnnotation,

945+ flushBuffer: flushBuffer

946+ };

947+})();

948+var build = /* #__PURE__ */ (function () {

949+ var go = function ($copy_cmd) {

950+ return function ($copy_stack) {

951+ var $tco_var_cmd = $copy_cmd;

952+ var $tco_done = false;

953+ var $tco_result;

954+ function $tco_loop(cmd, stack) {

955+ if (cmd instanceof BuildEnter) {

956+ if (cmd.value0 instanceof FullHeight) {

957+ if (cmd.value2 instanceof DocHApp) {

958+ $tco_var_cmd = new BuildEnter(cmd.value0, StpDone.value, cmd.value2.value1);

959+ $copy_stack = new BuildHAppR(cmd.value0.value0, cmd.value2.value0, cmd.value1, stack);

960+ return;

961+ };

962+ $tco_var_cmd = new BuildEnter(AsIs.value, cmd.value1, resize({

963+ width: 0,

964+ height: cmd.value0.value0

965+ })(cmd.value2));

966+ $copy_stack = stack;

967+ return;

968+ };

969+ if (cmd.value0 instanceof FullWidth) {

970+ if (cmd.value2 instanceof DocVApp) {

971+ $tco_var_cmd = new BuildEnter(cmd.value0, cmd.value1, cmd.value2.value1);

972+ $copy_stack = new BuildVAppR(cmd.value0.value0, cmd.value2.value0, stack);

973+ return;

974+ };

975+ $tco_var_cmd = new BuildEnter(AsIs.value, cmd.value1, resize({

976+ width: cmd.value0.value0,

977+ height: 0

978+ })(cmd.value2));

979+ $copy_stack = stack;

980+ return;

981+ };

982+ if (cmd.value0 instanceof AsIs) {

983+ if (cmd.value2 instanceof DocVApp) {

984+ $tco_var_cmd = new BuildEnter(new FullWidth(cmd.value2.value2.width), cmd.value1, cmd.value2.value1);

985+ $copy_stack = new BuildVAppR(cmd.value2.value2.width, cmd.value2.value0, stack);

986+ return;

987+ };

988+ if (cmd.value2 instanceof DocHApp) {

989+ $tco_var_cmd = new BuildEnter(new FullHeight(cmd.value2.value2.height), StpDone.value, cmd.value2.value1);

990+ $copy_stack = new BuildHAppR(cmd.value2.value2.height, cmd.value2.value0, cmd.value1, stack);

991+ return;

992+ };

993+ if (cmd.value2 instanceof DocAlign) {

994+ $tco_var_cmd = new BuildEnter(cmd.value0, cmd.value1, cmd.value2.value2);

995+ $copy_stack = stack;

996+ return;

997+ };

998+ if (cmd.value2 instanceof DocLine) {

999+ $tco_var_cmd = new BuildLeave(new StpLine(cmd.value2.value0, cmd.value1));

1000+ $copy_stack = stack;

1001+ return;

1002+ };

1003+ if (cmd.value2 instanceof DocPad) {

1004+ $tco_var_cmd = new BuildLeave(new StpPad(cmd.value2.value0.width, cmd.value2.value0.height, cmd.value1));

1005+ $copy_stack = stack;

1006+ return;

1007+ };

1008+ if (cmd.value2 instanceof DocEmpty) {

1009+ $tco_var_cmd = new BuildLeave(StpDone.value);

1010+ $copy_stack = stack;

1011+ return;

1012+ };

1013+ throw new Error("Failed pattern match at Dodo.Box (line 341, column 11 - line 353, column 44): " + [ cmd.value2.constructor.name ]);

1014+ };

1015+ throw new Error("Failed pattern match at Dodo.Box (line 327, column 7 - line 353, column 44): " + [ cmd.value0.constructor.name ]);

1016+ };

1017+ if (cmd instanceof BuildLeave) {

1018+ if (stack instanceof BuildVAppR) {

1019+ $tco_var_cmd = new BuildEnter(new FullWidth(stack.value0), cmd.value0, stack.value1);

1020+ $copy_stack = stack.value2;

1021+ return;

1022+ };

1023+ if (stack instanceof BuildHAppR) {

1024+ $tco_var_cmd = new BuildEnter(new FullHeight(stack.value0), StpDone.value, stack.value1);

1025+ $copy_stack = new BuildHAppH(cmd.value0, stack.value2, stack.value3);

1026+ return;

1027+ };

1028+ if (stack instanceof BuildHAppH) {

1029+ $tco_var_cmd = new BuildLeave(new StpHorz(cmd.value0, stack.value0, stack.value1));

1030+ $copy_stack = stack.value2;

1031+ return;

1032+ };

1033+ if (stack instanceof BuildNil) {

1034+ $tco_done = true;

1035+ return cmd.value0;

1036+ };

1037+ throw new Error("Failed pattern match at Dodo.Box (line 355, column 7 - line 363, column 15): " + [ stack.constructor.name ]);

1038+ };

1039+ throw new Error("Failed pattern match at Dodo.Box (line 325, column 18 - line 363, column 15): " + [ cmd.constructor.name ]);

1040+ };

1041+ while (!$tco_done) {

1042+ $tco_result = $tco_loop($tco_var_cmd, $copy_stack);

1043+ };

1044+ return $tco_result;

1045+ };

1046+ };

1047+ return function (size) {

1048+ return function (next) {

1049+ return function (box) {

1050+ return go(new BuildEnter(size, next, box))(BuildNil.value);

1051+ };

1052+ };

1053+ };

1054+})();

1055+var toDoc = /* #__PURE__ */ (function () {

1056+ var go2 = function ($copy_acc) {

1057+ return function ($copy_v) {

1058+ var $tco_var_acc = $copy_acc;

1059+ var $tco_done = false;

1060+ var $tco_result;

1061+ function $tco_loop(acc, v) {

1062+ if (v instanceof Data_Maybe.Nothing) {

1063+ $tco_done = true;

1064+ return acc;

1065+ };

1066+ if (v instanceof Data_Maybe.Just) {

1067+ $tco_var_acc = append(acc)(append(Dodo["break"])(formatLine(v.value0.line)));

1068+ $copy_v = resume(v.value0.next);

1069+ return;

1070+ };

1071+ throw new Error("Failed pattern match at Dodo.Box (line 278, column 13 - line 281, column 63): " + [ v.constructor.name ]);

1072+ };

1073+ while (!$tco_done) {

1074+ $tco_result = $tco_loop($tco_var_acc, $copy_v);

1075+ };

1076+ return $tco_result;

1077+ };

1078+ };

1079+ var go1 = function (v) {

1080+ if (v instanceof Data_Maybe.Nothing) {

1081+ return mempty;

1082+ };

1083+ if (v instanceof Data_Maybe.Just) {

1084+ return go2(formatLine(v.value0.line))(resume(v.value0.next));

1085+ };

1086+ throw new Error("Failed pattern match at Dodo.Box (line 273, column 9 - line 276, column 42): " + [ v.constructor.name ]);

1087+ };

1088+ var $281 = build(AsIs.value)(StpDone.value);

1089+ return function ($282) {

1090+ return go1(resume($281($282)));

1091+ };

1092+})();

1093+export {

1094+ Vertical,

1095+ Horizontal,

1096+ Start,

1097+ Middle,

1098+ End,

1099+ valign,

1100+ halign,

1101+ vappend,

1102+ happend,

1103+ vertical,

1104+ verticalWithAlign,

1105+ horizontal,

1106+ horizontalWithAlign,

1107+ resize,

1108+ fill,

1109+ vpadding,

1110+ hpadding,

1111+ sizeOf,

1112+ isEmpty,

1113+ empty,

1114+ toDoc,

1115+ docBox,

1116+ eqAlign,

1117+ functorDocBox,

1118+ newtypeVertical_,

1119+ functorVertical,

1120+ semigroupVertical,

1121+ monoidVertical,

1122+ newtypeHorizontal_,

1123+ functorHorizontal,

1124+ semigroupHorizontal,

1125+ monoidHorizontal

1126+};

output-compile-fail/Dodo.Common/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo.Common/index.jsnew file+74

@@ -0,0 +1,74 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Semigroup from "../Data.Semigroup/index.js";

3+import * as Dodo from "../Dodo/index.js";

4+import * as Dodo_Internal from "../Dodo.Internal/index.js";

5+var append = /* #__PURE__ */ Data_Semigroup.append(Dodo_Internal.semigroupDoc);

6+var trailingComma = /* #__PURE__ */ Dodo.flexAlt(/* #__PURE__ */ Dodo.text(", "))(/* #__PURE__ */ append(/* #__PURE__ */ Dodo.text(","))(Dodo["break"]));

7+var pursSquares = /* #__PURE__ */ (function () {

8+ var open = Dodo.text("[ ");

9+ var close = Dodo.flexAlt(Dodo.text(" ]"))(append(Dodo["break"])(Dodo.text("]")));

10+ var $2 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("[]"));

11+ return function ($3) {

12+ return Dodo.flexGroup($2($3));

13+ };

14+})();

15+var pursParensExpr = /* #__PURE__ */ (function () {

16+ var open = Dodo.text("(");

17+ var close = Dodo.text(")");

18+ var $4 = Dodo.enclose(open)(close);

19+ return function ($5) {

20+ return Dodo.flexGroup($4(Dodo.indent($5)));

21+ };

22+})();

23+var pursParens = /* #__PURE__ */ (function () {

24+ var open = Dodo.flexAlt(Dodo.text("("))(Dodo.text("( "));

25+ var close = Dodo.flexAlt(Dodo.text(")"))(append(Dodo["break"])(Dodo.text(")")));

26+ var $6 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("()"));

27+ return function ($7) {

28+ return Dodo.flexGroup($6($7));

29+ };

30+})();

31+var pursCurlies = /* #__PURE__ */ (function () {

32+ var open = Dodo.text("{ ");

33+ var close = Dodo.flexAlt(Dodo.text(" }"))(append(Dodo["break"])(Dodo.text("}")));

34+ var $8 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("{}"));

35+ return function ($9) {

36+ return Dodo.flexGroup($8($9));

37+ };

38+})();

39+var leadingComma = /* #__PURE__ */ Dodo.flexAlt(/* #__PURE__ */ Dodo.text(", "))(/* #__PURE__ */ append(Dodo["break"])(/* #__PURE__ */ Dodo.text(", ")));

40+var jsSquares = /* #__PURE__ */ (function () {

41+ var open = Dodo.flexAlt(Dodo.text("["))(append(Dodo.text("["))(Dodo["break"]));

42+ var close = Dodo.flexAlt(Dodo.text("]"))(append(Dodo["break"])(Dodo.text("]")));

43+ var $10 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("[]"));

44+ return function ($11) {

45+ return Dodo.flexGroup($10(Dodo.indent($11)));

46+ };

47+})();

48+var jsParens = /* #__PURE__ */ (function () {

49+ var open = Dodo.flexAlt(Dodo.text("("))(append(Dodo.text("("))(Dodo["break"]));

50+ var close = Dodo.flexAlt(Dodo.text(")"))(append(Dodo["break"])(Dodo.text(")")));

51+ var $12 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("()"));

52+ return function ($13) {

53+ return Dodo.flexGroup($12(Dodo.indent($13)));

54+ };

55+})();

56+var jsCurlies = /* #__PURE__ */ (function () {

57+ var open = Dodo.flexAlt(Dodo.text("{"))(append(Dodo.text("{"))(Dodo["break"]));

58+ var close = Dodo.flexAlt(Dodo.text("}"))(append(Dodo["break"])(Dodo.text("}")));

59+ var $14 = Dodo.encloseEmptyAlt(open)(close)(Dodo.text("{}"));

60+ return function ($15) {

61+ return Dodo.flexGroup($14(Dodo.indent($15)));

62+ };

63+})();

64+export {

65+ leadingComma,

66+ trailingComma,

67+ pursCurlies,

68+ pursSquares,

69+ pursParens,

70+ pursParensExpr,

71+ jsCurlies,

72+ jsSquares,

73+ jsParens

74+};

output-compile-fail/Dodo.Internal.Buffer/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo.Internal.Buffer/index.jsnew file+65

@@ -0,0 +1,65 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Foldable from "../Data.Foldable/index.js";

3+import * as Data_Function from "../Data.Function/index.js";

4+import * as Data_List from "../Data.List/index.js";

5+import * as Data_List_Types from "../Data.List.Types/index.js";

6+var foldr = /* #__PURE__ */ Data_Foldable.foldr(Data_List_Types.foldableList);

7+var Buffer = function (x) {

8+ return x;

9+};

10+var revert = function (v) {

11+ return {

12+ buffer: v.buffer,

13+ queue: Data_List.drop(1)(v.queue)

14+ };

15+};

16+var $$new = function (buffer) {

17+ return {

18+ buffer: buffer,

19+ queue: Data_List_Types.Nil.value

20+ };

21+};

22+var modify = function (f) {

23+ return function (v) {

24+ if (v.queue instanceof Data_List_Types.Cons) {

25+ return {

26+ buffer: v.buffer,

27+ queue: new Data_List_Types.Cons(new Data_List_Types.Cons(f, v.queue.value0), v.queue.value1)

28+ };

29+ };

30+ return {

31+ queue: v.queue,

32+ buffer: f(v.buffer)

33+ };

34+ };

35+};

36+var isBranching = function (v) {

37+ return !Data_List["null"](v.queue);

38+};

39+var commit = function (v) {

40+ return {

41+ buffer: foldr(Data_Function.flip(foldr(Data_Function.apply)))(v.buffer)(v.queue),

42+ queue: Data_List_Types.Nil.value

43+ };

44+};

45+var get = function ($23) {

46+ return (function (v) {

47+ return v.buffer;

48+ })(commit($23));

49+};

50+var branch = function (v) {

51+ return {

52+ buffer: v.buffer,

53+ queue: new Data_List_Types.Cons(Data_List_Types.Nil.value, v.queue)

54+ };

55+};

56+export {

57+ Buffer,

58+ branch,

59+ commit,

60+ revert,

61+ modify,

62+ get,

63+ $$new as new,

64+ isBranching

65+};

output-compile-fail/Dodo.Internal/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo.Internal/index.jsnew file+225

@@ -0,0 +1,225 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Functor from "../Data.Functor/index.js";

3+import * as Data_Tuple from "../Data.Tuple/index.js";

4+var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorFn);

5+var map1 = /* #__PURE__ */ Data_Functor.map(Data_Tuple.functorTuple);

6+var Append = /* #__PURE__ */ (function () {

7+ function Append(value0, value1) {

8+ this.value0 = value0;

9+ this.value1 = value1;

10+ };

11+ Append.create = function (value0) {

12+ return function (value1) {

13+ return new Append(value0, value1);

14+ };

15+ };

16+ return Append;

17+})();

18+var Indent = /* #__PURE__ */ (function () {

19+ function Indent(value0) {

20+ this.value0 = value0;

21+ };

22+ Indent.create = function (value0) {

23+ return new Indent(value0);

24+ };

25+ return Indent;

26+})();

27+var Align = /* #__PURE__ */ (function () {

28+ function Align(value0, value1) {

29+ this.value0 = value0;

30+ this.value1 = value1;

31+ };

32+ Align.create = function (value0) {

33+ return function (value1) {

34+ return new Align(value0, value1);

35+ };

36+ };

37+ return Align;

38+})();

39+var Annotate = /* #__PURE__ */ (function () {

40+ function Annotate(value0, value1) {

41+ this.value0 = value0;

42+ this.value1 = value1;

43+ };

44+ Annotate.create = function (value0) {

45+ return function (value1) {

46+ return new Annotate(value0, value1);

47+ };

48+ };

49+ return Annotate;

50+})();

51+var FlexSelect = /* #__PURE__ */ (function () {

52+ function FlexSelect(value0, value1, value2) {

53+ this.value0 = value0;

54+ this.value1 = value1;

55+ this.value2 = value2;

56+ };

57+ FlexSelect.create = function (value0) {

58+ return function (value1) {

59+ return function (value2) {

60+ return new FlexSelect(value0, value1, value2);

61+ };

62+ };

63+ };

64+ return FlexSelect;

65+})();

66+var FlexAlt = /* #__PURE__ */ (function () {

67+ function FlexAlt(value0, value1) {

68+ this.value0 = value0;

69+ this.value1 = value1;

70+ };

71+ FlexAlt.create = function (value0) {

72+ return function (value1) {

73+ return new FlexAlt(value0, value1);

74+ };

75+ };

76+ return FlexAlt;

77+})();

78+var WithPosition = /* #__PURE__ */ (function () {

79+ function WithPosition(value0) {

80+ this.value0 = value0;

81+ };

82+ WithPosition.create = function (value0) {

83+ return new WithPosition(value0);

84+ };

85+ return WithPosition;

86+})();

87+var Local = /* #__PURE__ */ (function () {

88+ function Local(value0) {

89+ this.value0 = value0;

90+ };

91+ Local.create = function (value0) {

92+ return new Local(value0);

93+ };

94+ return Local;

95+})();

96+var Text = /* #__PURE__ */ (function () {

97+ function Text(value0, value1) {

98+ this.value0 = value0;

99+ this.value1 = value1;

100+ };

101+ Text.create = function (value0) {

102+ return function (value1) {

103+ return new Text(value0, value1);

104+ };

105+ };

106+ return Text;

107+})();

108+var Break = /* #__PURE__ */ (function () {

109+ function Break() {

110+

111+ };

112+ Break.value = new Break();

113+ return Break;

114+})();

115+var Empty = /* #__PURE__ */ (function () {

116+ function Empty() {

117+

118+ };

119+ Empty.value = new Empty();

120+ return Empty;

121+})();

122+var notEmpty = function (f) {

123+ return function (v) {

124+ if (v instanceof Empty) {

125+ return Empty.value;

126+ };

127+ return f(v);

128+ };

129+};

130+var isEmpty = function (v) {

131+ if (v instanceof Empty) {

132+ return true;

133+ };

134+ return false;

135+};

136+var functorDoc = {

137+ map: function (f) {

138+ return function (m) {

139+ if (m instanceof Append) {

140+ return new Append(Data_Functor.map(functorDoc)(f)(m.value0), Data_Functor.map(functorDoc)(f)(m.value1));

141+ };

142+ if (m instanceof Indent) {

143+ return new Indent(Data_Functor.map(functorDoc)(f)(m.value0));

144+ };

145+ if (m instanceof Align) {

146+ return new Align(m.value0, Data_Functor.map(functorDoc)(f)(m.value1));

147+ };

148+ if (m instanceof Annotate) {

149+ return new Annotate(f(m.value0), Data_Functor.map(functorDoc)(f)(m.value1));

150+ };

151+ if (m instanceof FlexSelect) {

152+ return new FlexSelect(Data_Functor.map(functorDoc)(f)(m.value0), Data_Functor.map(functorDoc)(f)(m.value1), Data_Functor.map(functorDoc)(f)(m.value2));

153+ };

154+ if (m instanceof FlexAlt) {

155+ return new FlexAlt(Data_Functor.map(functorDoc)(f)(m.value0), Data_Functor.map(functorDoc)(f)(m.value1));

156+ };

157+ if (m instanceof WithPosition) {

158+ return new WithPosition(map(Data_Functor.map(functorDoc)(f))(m.value0));

159+ };

160+ if (m instanceof Local) {

161+ return new Local(map(map1(Data_Functor.map(functorDoc)(f)))(m.value0));

162+ };

163+ if (m instanceof Text) {

164+ return new Text(m.value0, m.value1);

165+ };

166+ if (m instanceof Break) {

167+ return Break.value;

168+ };

169+ if (m instanceof Empty) {

170+ return Empty.value;

171+ };

172+ throw new Error("Failed pattern match at Dodo.Internal (line 0, column 0 - line 0, column 0): " + [ m.constructor.name ]);

173+ };

174+ }

175+};

176+var bothNotEmpty = function (f) {

177+ return function (v) {

178+ return function (v1) {

179+ if (v instanceof Empty) {

180+ return v1;

181+ };

182+ if (v1 instanceof Empty) {

183+ return v;

184+ };

185+ return f(v)(v1);

186+ };

187+ };

188+};

189+var semigroupDoc = {

190+ append: /* #__PURE__ */ bothNotEmpty(function (v) {

191+ return function (v1) {

192+ if (v instanceof Text && v1 instanceof Text) {

193+ return new Text(v.value0 + v1.value0 | 0, v.value1 + v1.value1);

194+ };

195+ return new Append(v, v1);

196+ };

197+ })

198+};

199+var monoidDoc = /* #__PURE__ */ (function () {

200+ return {

201+ mempty: Empty.value,

202+ Semigroup0: function () {

203+ return semigroupDoc;

204+ }

205+ };

206+})();

207+export {

208+ Append,

209+ Indent,

210+ Align,

211+ Annotate,

212+ FlexSelect,

213+ FlexAlt,

214+ WithPosition,

215+ Local,

216+ Text,

217+ Break,

218+ Empty,

219+ bothNotEmpty,

220+ notEmpty,

221+ isEmpty,

222+ functorDoc,

223+ semigroupDoc,

224+ monoidDoc

225+};

output-compile-fail/Dodo/externs.cbornew file

Binary file not shown.

output-compile-fail/Dodo/index.jsnew file+794

@@ -0,0 +1,794 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Applicative from "../Control.Applicative/index.js";

3+import * as Data_Boolean from "../Data.Boolean/index.js";

4+import * as Data_Foldable from "../Data.Foldable/index.js";

5+import * as Data_Function from "../Data.Function/index.js";

6+import * as Data_Functor from "../Data.Functor/index.js";

7+import * as Data_Int from "../Data.Int/index.js";

8+import * as Data_List_Types from "../Data.List.Types/index.js";

9+import * as Data_Monoid from "../Data.Monoid/index.js";

10+import * as Data_Ord from "../Data.Ord/index.js";

11+import * as Data_Semigroup from "../Data.Semigroup/index.js";

12+import * as Data_String_CodePoints from "../Data.String.CodePoints/index.js";

13+import * as Data_String_Common from "../Data.String.Common/index.js";

14+import * as Data_String_Regex from "../Data.String.Regex/index.js";

15+import * as Data_String_Regex_Flags from "../Data.String.Regex.Flags/index.js";

16+import * as Data_String_Regex_Unsafe from "../Data.String.Regex.Unsafe/index.js";

17+import * as Data_Tuple from "../Data.Tuple/index.js";

18+import * as Dodo_Internal from "../Dodo.Internal/index.js";

19+import * as Dodo_Internal_Buffer from "../Dodo.Internal.Buffer/index.js";

20+var mempty = /* #__PURE__ */ Data_Monoid.mempty(Dodo_Internal.monoidDoc);

21+var append1 = /* #__PURE__ */ Data_Semigroup.append(Dodo_Internal.semigroupDoc);

22+var max = /* #__PURE__ */ Data_Ord.max(Data_Ord.ordInt);

23+var max1 = /* #__PURE__ */ Data_Ord.max(Data_Ord.ordNumber);

24+var min = /* #__PURE__ */ Data_Ord.min(Data_Ord.ordNumber);

25+var power = /* #__PURE__ */ Data_Monoid.power(Data_Monoid.monoidString);

26+var pure = /* #__PURE__ */ Control_Applicative.pure(Data_List_Types.applicativeList);

27+var Printer = function (x) {

28+ return x;

29+};

30+var Doc = /* #__PURE__ */ (function () {

31+ function Doc(value0) {

32+ this.value0 = value0;

33+ };

34+ Doc.create = function (value0) {

35+ return new Doc(value0);

36+ };

37+ return Doc;

38+})();

39+var Dedent = /* #__PURE__ */ (function () {

40+ function Dedent(value0, value1) {

41+ this.value0 = value0;

42+ this.value1 = value1;

43+ };

44+ Dedent.create = function (value0) {

45+ return function (value1) {

46+ return new Dedent(value0, value1);

47+ };

48+ };

49+ return Dedent;

50+})();

51+var LeaveAnnotation = /* #__PURE__ */ (function () {

52+ function LeaveAnnotation(value0, value1) {

53+ this.value0 = value0;

54+ this.value1 = value1;

55+ };

56+ LeaveAnnotation.create = function (value0) {

57+ return function (value1) {

58+ return new LeaveAnnotation(value0, value1);

59+ };

60+ };

61+ return LeaveAnnotation;

62+})();

63+var LeaveFlexGroup = /* #__PURE__ */ (function () {

64+ function LeaveFlexGroup(value0, value1) {

65+ this.value0 = value0;

66+ this.value1 = value1;

67+ };

68+ LeaveFlexGroup.create = function (value0) {

69+ return function (value1) {

70+ return new LeaveFlexGroup(value0, value1);

71+ };

72+ };

73+ return LeaveFlexGroup;

74+})();

75+var LeaveLocal = /* #__PURE__ */ (function () {

76+ function LeaveLocal(value0) {

77+ this.value0 = value0;

78+ };

79+ LeaveLocal.create = function (value0) {

80+ return new LeaveLocal(value0);

81+ };

82+ return LeaveLocal;

83+})();

84+var NoFlexGroup = /* #__PURE__ */ (function () {

85+ function NoFlexGroup() {

86+

87+ };

88+ NoFlexGroup.value = new NoFlexGroup();

89+ return NoFlexGroup;

90+})();

91+var FlexGroupPending = /* #__PURE__ */ (function () {

92+ function FlexGroupPending() {

93+

94+ };

95+ FlexGroupPending.value = new FlexGroupPending();

96+ return FlexGroupPending;

97+})();

98+var FlexGroupReset = /* #__PURE__ */ (function () {

99+ function FlexGroupReset(value0) {

100+ this.value0 = value0;

101+ };

102+ FlexGroupReset.create = function (value0) {

103+ return new FlexGroupReset(value0);

104+ };

105+ return FlexGroupReset;

106+})();

107+var withPosition = /* #__PURE__ */ (function () {

108+ return Dodo_Internal.WithPosition.create;

109+})();

110+var withLocalOptions = /* #__PURE__ */ (function () {

111+ return Dodo_Internal.Local.create;

112+})();

113+var twoSpaces = {

114+ pageWidth: 80,

115+ ribbonRatio: 1.0,

116+ indentUnit: " ",

117+ indentWidth: 2

118+};

119+var text = function (v) {

120+ if (v === "") {

121+ return Dodo_Internal.Empty.value;

122+ };

123+ return new Dodo_Internal.Text(Data_String_CodePoints.length(v), v);

124+};

125+var tabs = {

126+ pageWidth: 120,

127+ ribbonRatio: 1.0,

128+ indentUnit: "\x09",

129+ indentWidth: 4

130+};

131+var storeState = function (stack) {

132+ return function (v) {

133+ return {

134+ position: v.position,

135+ buffer: v.buffer,

136+ annotations: v.annotations,

137+ indentSpaces: v.indentSpaces,

138+ stack: stack,

139+ options: v.options

140+ };

141+ };

142+};

143+var space = /* #__PURE__ */ text(" ");

144+var resetState = function (v) {

145+ return {

146+ position: v.position,

147+ buffer: v.buffer,

148+ annotations: v.annotations,

149+ indentSpaces: v.indentSpaces,

150+ flexGroup: NoFlexGroup.value,

151+ options: v.options

152+ };

153+};

154+var plainText = {

155+ emptyBuffer: "",

156+ writeText: function (v) {

157+ return function (str) {

158+ return function (buff) {

159+ return buff + str;

160+ };

161+ };

162+ },

163+ writeIndent: function (v) {

164+ return function (str) {

165+ return function (buff) {

166+ return buff + str;

167+ };

168+ };

169+ },

170+ writeBreak: function (buff) {

171+ return buff + "\x0a";

172+ },

173+ enterAnnotation: function (v) {

174+ return function (v1) {

175+ return function (buff) {

176+ return buff;

177+ };

178+ };

179+ },

180+ leaveAnnotation: function (v) {

181+ return function (v1) {

182+ return function (buff) {

183+ return buff;

184+ };

185+ };

186+ },

187+ flushBuffer: function (buff) {

188+ return buff;

189+ }

190+};

191+var locally = function (k) {

192+ return function (doc) {

193+ return new Dodo_Internal.Local(function (options) {

194+ return new Data_Tuple.Tuple(k(options), doc);

195+ });

196+ };

197+};

198+var indent = /* #__PURE__ */ (function () {

199+ return Dodo_Internal.notEmpty(Dodo_Internal.Indent.create);

200+})();

201+var fourSpaces = {

202+ pageWidth: 120,

203+ ribbonRatio: 1.0,

204+ indentUnit: " ",

205+ indentWidth: 4

206+};

207+var foldWith = function (dictFoldable) {

208+ var foldr = Data_Foldable.foldr(dictFoldable);

209+ return function (f) {

210+ return foldr(Dodo_Internal.bothNotEmpty(f))(mempty);

211+ };

212+};

213+var foldWithSeparator = function (dictFoldable) {

214+ var foldWith1 = foldWith(dictFoldable);

215+ return function (separator) {

216+ return foldWith1(function (a) {

217+ return function (b) {

218+ return append1(a)(append1(separator)(b));

219+ };

220+ });

221+ };

222+};

223+var flexSelect = function (doc1) {

224+ return function (doc2) {

225+ return function (doc3) {

226+ if (Dodo_Internal.isEmpty(doc1)) {

227+ return doc2;

228+ };

229+ if (Data_Boolean.otherwise) {

230+ return new Dodo_Internal.FlexSelect(doc1, doc2, doc3);

231+ };

232+ throw new Error("Failed pattern match at Dodo (line 89, column 1 - line 89, column 57): " + [ doc1.constructor.name, doc2.constructor.name, doc3.constructor.name ]);

233+ };

234+ };

235+};

236+var flexGroup = /* #__PURE__ */ Dodo_Internal.notEmpty(function (v) {

237+ if (v instanceof Dodo_Internal.FlexSelect && (Dodo_Internal.isEmpty(v.value1) && Dodo_Internal.isEmpty(v.value2))) {

238+ return v;

239+ };

240+ return new Dodo_Internal.FlexSelect(v, Dodo_Internal.Empty.value, Dodo_Internal.Empty.value);

241+});

242+var flexAlt = /* #__PURE__ */ (function () {

243+ return Dodo_Internal.FlexAlt.create;

244+})();

245+var encloseWithSeparator = function (dictFoldable) {

246+ var foldWithSeparator1 = foldWithSeparator(dictFoldable);

247+ return function (open) {

248+ return function (close) {

249+ return function (separator) {

250+ return function (inner) {

251+ return append1(open)(append1(foldWithSeparator1(separator)(inner))(close));

252+ };

253+ };

254+ };

255+ };

256+};

257+var encloseEmptyAlt = function (open) {

258+ return function (close) {

259+ return function ($$default) {

260+ return function (inner) {

261+ if (Dodo_Internal.isEmpty(inner)) {

262+ return $$default;

263+ };

264+ if (Data_Boolean.otherwise) {

265+ return append1(open)(append1(inner)(close));

266+ };

267+ throw new Error("Failed pattern match at Dodo (line 176, column 1 - line 176, column 71): " + [ open.constructor.name, close.constructor.name, $$default.constructor.name, inner.constructor.name ]);

268+ };

269+ };

270+ };

271+};

272+var enclose = function (open) {

273+ return function (close) {

274+ return function (inner) {

275+ return append1(open)(append1(inner)(close));

276+ };

277+ };

278+};

279+var calcRibbonWidth = function (v) {

280+ return function (n) {

281+ return max(0)(Data_Int.ceil(v.ribbonRatio * Data_Int.toNumber(v.pageWidth - n | 0)));

282+ };

283+};

284+var storeOptions = function (prevIndent) {

285+ return function (localOptions) {

286+ return function (state) {

287+ var newOptions = {

288+ indentUnit: localOptions.indentUnit,

289+ indentWidth: localOptions.indentWidth,

290+ pageWidth: localOptions.pageWidth,

291+ ribbonRatio: localOptions.ribbonRatio

292+ };

293+ return {

294+ buffer: state.buffer,

295+ annotations: state.annotations,

296+ flexGroup: state.flexGroup,

297+ indentSpaces: localOptions.indentSpaces,

298+ options: newOptions,

299+ position: {

300+ line: state.position.line,

301+ column: state.position.column,

302+ indent: state.position.indent,

303+ pageWidth: newOptions.pageWidth,

304+ ribbonWidth: calcRibbonWidth(newOptions)(prevIndent),

305+ nextIndent: localOptions.indent

306+ }

307+ };

308+ };

309+ };

310+};

311+var print = function (v) {

312+ return function (opts) {

313+ var initOptions = {

314+ pageWidth: opts.pageWidth,

315+ indentUnit: opts.indentUnit,

316+ indentWidth: opts.indentWidth,

317+ ribbonRatio: max1(0.0)(min(1.0)(opts.ribbonRatio))

318+ };

319+ var initState = {

320+ position: {

321+ line: 0,

322+ column: 0,

323+ indent: 0,

324+ nextIndent: 0,

325+ pageWidth: initOptions.pageWidth,

326+ ribbonWidth: calcRibbonWidth(initOptions)(0)

327+ },

328+ buffer: Dodo_Internal_Buffer["new"](v.emptyBuffer),

329+ annotations: Data_List_Types.Nil.value,

330+ indentSpaces: "",

331+ flexGroup: NoFlexGroup.value,

332+ options: initOptions

333+ };

334+ var go = function ($copy_stack) {

335+ return function ($copy_state) {

336+ var $tco_var_stack = $copy_stack;

337+ var $tco_done = false;

338+ var $tco_result;

339+ function $tco_loop(stack, state) {

340+ if (stack instanceof Data_List_Types.Nil) {

341+ $tco_done = true;

342+ return v.flushBuffer(Dodo_Internal_Buffer.get(state.buffer));

343+ };

344+ if (stack instanceof Data_List_Types.Cons) {

345+ if (stack.value0 instanceof Doc) {

346+ if (stack.value0.value0 instanceof Dodo_Internal.Append) {

347+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), stack.value1));

348+ $copy_state = state;

349+ return;

350+ };

351+ if (stack.value0.value0 instanceof Dodo_Internal.Text) {

352+ if (state.position.column === 0 && state.position.indent > 0) {

353+ $tco_var_stack = stack;

354+ $copy_state = {

355+ annotations: state.annotations,

356+ indentSpaces: state.indentSpaces,

357+ flexGroup: state.flexGroup,

358+ options: state.options,

359+ position: {

360+ line: state.position.line,

361+ indent: state.position.indent,

362+ nextIndent: state.position.nextIndent,

363+ pageWidth: state.position.pageWidth,

364+ ribbonWidth: state.position.ribbonWidth,

365+ column: state.position.indent

366+ },

367+ buffer: Dodo_Internal_Buffer.modify(v.writeIndent(state.position.indent)(state.indentSpaces))(state.buffer)

368+ };

369+ return;

370+ };

371+ if ((state.position.column + stack.value0.value0.value0 | 0) <= (state.position.indent + state.position.ribbonWidth | 0)) {

372+ $tco_var_stack = stack.value1;

373+ $copy_state = {

374+ annotations: state.annotations,

375+ indentSpaces: state.indentSpaces,

376+ flexGroup: state.flexGroup,

377+ options: state.options,

378+ position: {

379+ line: state.position.line,

380+ indent: state.position.indent,

381+ nextIndent: state.position.nextIndent,

382+ pageWidth: state.position.pageWidth,

383+ ribbonWidth: state.position.ribbonWidth,

384+ column: state.position.column + stack.value0.value0.value0 | 0

385+ },

386+ buffer: Dodo_Internal_Buffer.modify(v.writeText(stack.value0.value0.value0)(stack.value0.value0.value1))(state.buffer)

387+ };

388+ return;

389+ };

390+ if (Data_Boolean.otherwise) {

391+ if (state.flexGroup instanceof FlexGroupReset) {

392+ $tco_var_stack = state.flexGroup.value0.stack;

393+ $copy_state = resetState(state.flexGroup.value0);

394+ return;

395+ };

396+ $tco_var_stack = stack.value1;

397+ $copy_state = {

398+ annotations: state.annotations,

399+ indentSpaces: state.indentSpaces,

400+ options: state.options,

401+ position: {

402+ line: state.position.line,

403+ indent: state.position.indent,

404+ nextIndent: state.position.nextIndent,

405+ pageWidth: state.position.pageWidth,

406+ ribbonWidth: state.position.ribbonWidth,

407+ column: state.position.column + stack.value0.value0.value0 | 0

408+ },

409+ flexGroup: NoFlexGroup.value,

410+ buffer: Dodo_Internal_Buffer.modify(v.writeText(stack.value0.value0.value0)(stack.value0.value0.value1))(state.buffer)

411+ };

412+ return;

413+ };

414+ };

415+ if (stack.value0.value0 instanceof Dodo_Internal.Break) {

416+ if (state.flexGroup instanceof FlexGroupReset) {

417+ $tco_var_stack = state.flexGroup.value0.stack;

418+ $copy_state = resetState(state.flexGroup.value0);

419+ return;

420+ };

421+ $tco_var_stack = stack.value1;

422+ $copy_state = {

423+ annotations: state.annotations,

424+ indentSpaces: state.indentSpaces,

425+ options: state.options,

426+ position: {

427+ nextIndent: state.position.nextIndent,

428+ pageWidth: state.position.pageWidth,

429+ line: state.position.line + 1 | 0,

430+ column: 0,

431+ indent: state.position.nextIndent,

432+ ribbonWidth: calcRibbonWidth(state.options)(state.position.nextIndent)

433+ },

434+ buffer: Dodo_Internal_Buffer.modify(v.writeBreak)(state.buffer),

435+ flexGroup: NoFlexGroup.value

436+ };

437+ return;

438+ };

439+ if (stack.value0.value0 instanceof Dodo_Internal.Indent) {

440+ if (state.position.column === 0) {

441+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new Dedent(state.indentSpaces, state.position.nextIndent), stack.value1));

442+ $copy_state = {

443+ buffer: state.buffer,

444+ annotations: state.annotations,

445+ flexGroup: state.flexGroup,

446+ options: state.options,

447+ position: {

448+ line: state.position.line,

449+ column: state.position.column,

450+ pageWidth: state.position.pageWidth,

451+ indent: state.position.nextIndent + opts.indentWidth | 0,

452+ nextIndent: state.position.nextIndent + opts.indentWidth | 0,

453+ ribbonWidth: calcRibbonWidth(state.options)(state.position.nextIndent + opts.indentWidth | 0)

454+ },

455+ indentSpaces: state.indentSpaces + opts.indentUnit

456+ };

457+ return;

458+ };

459+ if (Data_Boolean.otherwise) {

460+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new Dedent(state.indentSpaces, state.position.nextIndent), stack.value1));

461+ $copy_state = {

462+ buffer: state.buffer,

463+ annotations: state.annotations,

464+ flexGroup: state.flexGroup,

465+ options: state.options,

466+ position: {

467+ line: state.position.line,

468+ column: state.position.column,

469+ indent: state.position.indent,

470+ pageWidth: state.position.pageWidth,

471+ ribbonWidth: state.position.ribbonWidth,

472+ nextIndent: state.position.nextIndent + opts.indentWidth | 0

473+ },

474+ indentSpaces: state.indentSpaces + opts.indentUnit

475+ };

476+ return;

477+ };

478+ };

479+ if (stack.value0.value0 instanceof Dodo_Internal.Align) {

480+ if (state.position.column === 0) {

481+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), new Data_List_Types.Cons(new Dedent(state.indentSpaces, state.position.nextIndent), stack.value1));

482+ $copy_state = {

483+ buffer: state.buffer,

484+ annotations: state.annotations,

485+ flexGroup: state.flexGroup,

486+ options: state.options,

487+ position: {

488+ line: state.position.line,

489+ column: state.position.column,

490+ pageWidth: state.position.pageWidth,

491+ indent: state.position.nextIndent + stack.value0.value0.value0 | 0,

492+ nextIndent: state.position.nextIndent + stack.value0.value0.value0 | 0,

493+ ribbonWidth: calcRibbonWidth(state.options)(state.position.nextIndent + stack.value0.value0.value0 | 0)

494+ },

495+ indentSpaces: state.indentSpaces + power(" ")(stack.value0.value0.value0)

496+ };

497+ return;

498+ };

499+ if (Data_Boolean.otherwise) {

500+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), new Data_List_Types.Cons(new Dedent(state.indentSpaces, state.position.nextIndent), stack.value1));

501+ $copy_state = {

502+ buffer: state.buffer,

503+ annotations: state.annotations,

504+ flexGroup: state.flexGroup,

505+ options: state.options,

506+ position: {

507+ line: state.position.line,

508+ column: state.position.column,

509+ indent: state.position.indent,

510+ pageWidth: state.position.pageWidth,

511+ ribbonWidth: state.position.ribbonWidth,

512+ nextIndent: state.position.nextIndent + stack.value0.value0.value0 | 0

513+ },

514+ indentSpaces: state.indentSpaces + power(" ")(stack.value0.value0.value0)

515+ };

516+ return;

517+ };

518+ };

519+ if (stack.value0.value0 instanceof Dodo_Internal.FlexSelect) {

520+ if (state.flexGroup instanceof NoFlexGroup) {

521+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new LeaveFlexGroup(stack.value0.value0.value1, stack.value0.value0.value2), stack.value1));

522+ $copy_state = {

523+ position: state.position,

524+ buffer: state.buffer,

525+ annotations: state.annotations,

526+ indentSpaces: state.indentSpaces,

527+ options: state.options,

528+ flexGroup: FlexGroupPending.value

529+ };

530+ return;

531+ };

532+ if (state.flexGroup instanceof FlexGroupPending && state.position.ribbonWidth > 0) {

533+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), stack.value1));

534+ $copy_state = {

535+ position: state.position,

536+ annotations: state.annotations,

537+ indentSpaces: state.indentSpaces,

538+ options: state.options,

539+ flexGroup: new FlexGroupReset(storeState(stack)(state)),

540+ buffer: Dodo_Internal_Buffer.branch(state.buffer)

541+ };

542+ return;

543+ };

544+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), stack.value1));

545+ $copy_state = state;

546+ return;

547+ };

548+ if (stack.value0.value0 instanceof Dodo_Internal.FlexAlt) {

549+ if (state.flexGroup instanceof FlexGroupReset) {

550+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), stack.value1);

551+ $copy_state = state;

552+ return;

553+ };

554+ if (state.flexGroup instanceof FlexGroupPending && state.position.ribbonWidth > 0) {

555+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0), stack.value1);

556+ $copy_state = {

557+ position: state.position,

558+ annotations: state.annotations,

559+ indentSpaces: state.indentSpaces,

560+ options: state.options,

561+ flexGroup: new FlexGroupReset(storeState(new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), stack.value1))(state)),

562+ buffer: Dodo_Internal_Buffer.branch(state.buffer)

563+ };

564+ return;

565+ };

566+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), stack.value1);

567+ $copy_state = state;

568+ return;

569+ };

570+ if (stack.value0.value0 instanceof Dodo_Internal.WithPosition) {

571+ if (state.position.column === 0 && state.position.nextIndent > 0) {

572+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0({

573+ line: state.position.line,

574+ indent: state.position.indent,

575+ nextIndent: state.position.nextIndent,

576+ pageWidth: state.position.pageWidth,

577+ ribbonWidth: state.position.ribbonWidth,

578+ column: state.position.nextIndent

579+ })), stack.value1);

580+ $copy_state = state;

581+ return;

582+ };

583+ if (Data_Boolean.otherwise) {

584+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value0(state.position)), stack.value1);

585+ $copy_state = state;

586+ return;

587+ };

588+ };

589+ if (stack.value0.value0 instanceof Dodo_Internal.Annotate) {

590+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0.value1), new Data_List_Types.Cons(new LeaveAnnotation(stack.value0.value0.value0, state.annotations), stack.value1));

591+ $copy_state = {

592+ position: state.position,

593+ indentSpaces: state.indentSpaces,

594+ flexGroup: state.flexGroup,

595+ options: state.options,

596+ annotations: new Data_List_Types.Cons(stack.value0.value0.value0, state.annotations),

597+ buffer: Dodo_Internal_Buffer.modify(v.enterAnnotation(stack.value0.value0.value0)(state.annotations))(state.buffer)

598+ };

599+ return;

600+ };

601+ if (stack.value0.value0 instanceof Dodo_Internal.Local) {

602+ var prevOptions = {

603+ indent: state.position.indent,

604+ indentSpaces: state.indentSpaces,

605+ indentUnit: state.options.indentUnit,

606+ indentWidth: state.options.indentWidth,

607+ pageWidth: state.options.pageWidth,

608+ ribbonRatio: state.options.ribbonRatio

609+ };

610+ var v1 = stack.value0.value0.value0(prevOptions);

611+ $tco_var_stack = new Data_List_Types.Cons(new Doc(v1.value1), new Data_List_Types.Cons(new LeaveLocal(prevOptions), stack.value1));

612+ $copy_state = storeOptions(state.position.indent)(v1.value0)(state);

613+ return;

614+ };

615+ if (stack.value0.value0 instanceof Dodo_Internal.Empty) {

616+ $tco_var_stack = stack.value1;

617+ $copy_state = state;

618+ return;

619+ };

620+ throw new Error("Failed pattern match at Dodo (line 365, column 18 - line 477, column 23): " + [ stack.value0.value0.constructor.name ]);

621+ };

622+ if (stack.value0 instanceof LeaveFlexGroup) {

623+ if (state.flexGroup instanceof NoFlexGroup) {

624+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value1), stack.value1);

625+ $copy_state = {

626+ position: state.position,

627+ annotations: state.annotations,

628+ indentSpaces: state.indentSpaces,

629+ flexGroup: state.flexGroup,

630+ options: state.options,

631+ buffer: Dodo_Internal_Buffer.commit(state.buffer)

632+ };

633+ return;

634+ };

635+ $tco_var_stack = new Data_List_Types.Cons(new Doc(stack.value0.value0), stack.value1);

636+ $copy_state = {

637+ position: state.position,

638+ annotations: state.annotations,

639+ indentSpaces: state.indentSpaces,

640+ options: state.options,

641+ flexGroup: NoFlexGroup.value,

642+ buffer: Dodo_Internal_Buffer.commit(state.buffer)

643+ };

644+ return;

645+ };

646+ if (stack.value0 instanceof Dedent) {

647+ $tco_var_stack = stack.value1;

648+ $copy_state = {

649+ buffer: state.buffer,

650+ annotations: state.annotations,

651+ flexGroup: state.flexGroup,

652+ options: state.options,

653+ position: {

654+ line: state.position.line,

655+ column: state.position.column,

656+ indent: state.position.indent,

657+ pageWidth: state.position.pageWidth,

658+ ribbonWidth: state.position.ribbonWidth,

659+ nextIndent: stack.value0.value1

660+ },

661+ indentSpaces: stack.value0.value0

662+ };

663+ return;

664+ };

665+ if (stack.value0 instanceof LeaveAnnotation) {

666+ $tco_var_stack = stack.value1;

667+ $copy_state = {

668+ position: state.position,

669+ indentSpaces: state.indentSpaces,

670+ flexGroup: state.flexGroup,

671+ options: state.options,

672+ annotations: stack.value0.value1,

673+ buffer: Dodo_Internal_Buffer.modify(v.leaveAnnotation(stack.value0.value0)(stack.value0.value1))(state.buffer)

674+ };

675+ return;

676+ };

677+ if (stack.value0 instanceof LeaveLocal) {

678+ $tco_var_stack = stack.value1;

679+ $copy_state = storeOptions(state.position.indent)(stack.value0.value0)(state);

680+ return;

681+ };

682+ throw new Error("Failed pattern match at Dodo (line 364, column 18 - line 499, column 70): " + [ stack.value0.constructor.name ]);

683+ };

684+ throw new Error("Failed pattern match at Dodo (line 361, column 20 - line 499, column 70): " + [ stack.constructor.name ]);

685+ };

686+ while (!$tco_done) {

687+ $tco_result = $tco_loop($tco_var_stack, $copy_state);

688+ };

689+ return $tco_result;

690+ };

691+ };

692+ var $135 = Data_Function.flip(go)(initState);

693+ return function ($136) {

694+ return $135(pure(Doc.create($136)));

695+ };

696+ };

697+};

698+var $$break = /* #__PURE__ */ (function () {

699+ return Dodo_Internal.Break.value;

700+})();

701+var softBreak = /* #__PURE__ */ flexAlt(mempty)($$break);

702+var spaceBreak = /* #__PURE__ */ flexAlt(space)($$break);

703+var appendSpaceBreak = /* #__PURE__ */ Dodo_Internal.bothNotEmpty(function (a) {

704+ return function (b) {

705+ return append1(a)(flexGroup(append1(spaceBreak)(b)));

706+ };

707+});

708+var paragraph = function (dictFoldable) {

709+ return Data_Foldable.foldl(dictFoldable)(appendSpaceBreak)(Dodo_Internal.Empty.value);

710+};

711+var textParagraph = /* #__PURE__ */ (function () {

712+ var spaceRegex = Data_String_Regex_Unsafe.unsafeRegex("[\\s\\n]+")(Data_String_Regex_Flags.global);

713+ var $137 = paragraph(Data_Foldable.foldableArray);

714+ var $138 = Data_Functor.map(Data_Functor.functorArray)(text);

715+ var $139 = Data_String_Regex.split(spaceRegex);

716+ return function ($140) {

717+ return $137($138($139(Data_String_Common.trim($140))));

718+ };

719+})();

720+var appendSpace = /* #__PURE__ */ Dodo_Internal.bothNotEmpty(function (a) {

721+ return function (b) {

722+ return append1(a)(append1(space)(b));

723+ };

724+});

725+var words = function (dictFoldable) {

726+ return Data_Foldable.foldr(dictFoldable)(appendSpace)(Dodo_Internal.Empty.value);

727+};

728+var appendBreak = /* #__PURE__ */ Dodo_Internal.bothNotEmpty(function (a) {

729+ return function (b) {

730+ return append1(a)(append1($$break)(b));

731+ };

732+});

733+var lines = function (dictFoldable) {

734+ return Data_Foldable.foldr(dictFoldable)(appendBreak)(Dodo_Internal.Empty.value);

735+};

736+var annotate = function ($141) {

737+ return Dodo_Internal.notEmpty(Dodo_Internal.Annotate.create($141));

738+};

739+var align = function (n) {

740+ return function (doc) {

741+ if (n > 0) {

742+ return Dodo_Internal.notEmpty(Dodo_Internal.Align.create(n))(doc);

743+ };

744+ if (Data_Boolean.otherwise) {

745+ return doc;

746+ };

747+ throw new Error("Failed pattern match at Dodo (line 64, column 1 - line 64, column 41): " + [ n.constructor.name, doc.constructor.name ]);

748+ };

749+};

750+var alignCurrentColumn = /* #__PURE__ */ Dodo_Internal.notEmpty(function (doc) {

751+ return withPosition(function (pos) {

752+ return align(pos.column - pos.nextIndent | 0)(doc);

753+ });

754+});

755+export {

756+ indent,

757+ align,

758+ alignCurrentColumn,

759+ annotate,

760+ withPosition,

761+ text,

762+ $$break as break,

763+ spaceBreak,

764+ softBreak,

765+ space,

766+ lines,

767+ words,

768+ appendBreak,

769+ appendSpace,

770+ appendSpaceBreak,

771+ flexAlt,

772+ flexGroup,

773+ flexSelect,

774+ paragraph,

775+ textParagraph,

776+ enclose,

777+ encloseEmptyAlt,

778+ encloseWithSeparator,

779+ foldWithSeparator,

780+ foldWith,

781+ locally,

782+ withLocalOptions,

783+ print,

784+ Printer,

785+ plainText,

786+ twoSpaces,

787+ fourSpaces,

788+ tabs

789+};

790+export {

791+ bothNotEmpty,

792+ isEmpty,

793+ notEmpty

794+} from "../Dodo.Internal/index.js";

output-compile-fail/Prospero.Bun/externs.cbornew file

Binary file not shown.

output-compile-fail/Prospero.Bun/index.jsnew file+199

@@ -0,0 +1,199 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Bind from "../Control.Bind/index.js";

3+import * as Data_Either from "../Data.Either/index.js";

4+import * as Data_Eq from "../Data.Eq/index.js";

5+import * as Data_Maybe from "../Data.Maybe/index.js";

6+import * as Data_Unit from "../Data.Unit/index.js";

7+import * as Effect_Aff from "../Effect.Aff/index.js";

8+import * as Effect_Class from "../Effect.Class/index.js";

9+import * as Effect_Ref from "../Effect.Ref/index.js";

10+import * as Effect_Uncurried from "../Effect.Uncurried/index.js";

11+import * as Foreign from "../Foreign/index.js";

12+import * as Promise_Aff from "../Promise.Aff/index.js";

13+import * as Prospero_GraphQLError from "../Prospero.GraphQLError/index.js";

14+import * as Prospero_GraphQLWS from "../Prospero.GraphQLWS/index.js";

15+import * as Prospero_Http from "../Prospero.Http/index.js";

16+import * as Prospero_ResponseValue from "../Prospero.ResponseValue/index.js";

17+import * as Yoga_Bun_HTTP from "../Yoga.Bun.HTTP/index.js";

18+import * as Yoga_JSON from "../Yoga.JSON/index.js";

19+var eq = /* #__PURE__ */ Data_Eq.eq(/* #__PURE__ */ Data_Maybe.eqMaybe(Data_Eq.eqString));

20+var bind1 = /* #__PURE__ */ Control_Bind.bind(Effect_Aff.bindAff);

21+var readJSON_ = /* #__PURE__ */ Yoga_JSON.readJSON_(Yoga_JSON.readForeignForeign);

22+var liftEffect = /* #__PURE__ */ Effect_Class.liftEffect(Effect_Aff.monadEffectAff);

23+var jsonResponse = /* #__PURE__ */ Yoga_Bun_HTTP.jsonResponse();

24+var fromAff = /* #__PURE__ */ Promise_Aff.fromAff();

25+var serve1 = /* #__PURE__ */ Yoga_Bun_HTTP.serve();

26+var wsOpen = function (schema) {

27+ return function (run) {

28+ return function (onSubscribe) {

29+ return function (callbacksRef) {

30+ return function (bws) {

31+ return function __do() {

32+ var cbs = Prospero_GraphQLWS.handleGraphQLWS(schema)(run)(onSubscribe)(bws)();

33+ return Effect_Ref.write(new Data_Maybe.Just(cbs))(callbacksRef)();

34+ };

35+ };

36+ };

37+ };

38+ };

39+};

40+var wsMessage = function (callbacksRef) {

41+ return function (v) {

42+ return function (msg) {

43+ return function __do() {

44+ var mcbs = Effect_Ref.read(callbacksRef)();

45+ if (mcbs instanceof Data_Maybe.Just) {

46+ return mcbs.value0.onMessage(msg)();

47+ };

48+ if (mcbs instanceof Data_Maybe.Nothing) {

49+ return Data_Unit.unit;

50+ };

51+ throw new Error("Failed pattern match at Prospero.Bun (line 120, column 3 - line 122, column 25): " + [ mcbs.constructor.name ]);

52+ };

53+ };

54+ };

55+};

56+var wsClose = function (callbacksRef) {

57+ return function (v) {

58+ return function (v1) {

59+ return function __do() {

60+ var mcbs = Effect_Ref.read(callbacksRef)();

61+ if (mcbs instanceof Data_Maybe.Just) {

62+ return mcbs.value0.onClose();

63+ };

64+ if (mcbs instanceof Data_Maybe.Nothing) {

65+ return Data_Unit.unit;

66+ };

67+ throw new Error("Failed pattern match at Prospero.Bun (line 127, column 3 - line 129, column 25): " + [ mcbs.constructor.name ]);

68+ };

69+ };

70+ };

71+};

72+var upgradeRequested = function (req) {

73+ return eq(Yoga_Bun_HTTP.requestHeader(req)("upgrade"))(new Data_Maybe.Just("websocket"));

74+};

75+var upgrade = function (serverF) {

76+ return function (reqF) {

77+ return serverF.upgrade(reqF);

78+ };

79+};

80+var handlePost = function (schema) {

81+ return function (run) {

82+ return function (req) {

83+ return bind1(Yoga_Bun_HTTP.requestText(req))(function (text) {

84+ var v = readJSON_(text);

85+ if (v instanceof Data_Maybe.Nothing) {

86+ return liftEffect(jsonResponse(Foreign.unsafeToForeign({

87+ errors: [ {

88+ message: "Invalid JSON body"

89+ } ]

90+ }))({

91+ status: 400

92+ }));

93+ };

94+ if (v instanceof Data_Maybe.Just) {

95+ var rv = Prospero_ResponseValue.foreignToResponseValue(v.value0);

96+ var v1 = Prospero_Http.decodeRequest(rv);

97+ if (v1 instanceof Data_Either.Left) {

98+ return liftEffect(jsonResponse(Foreign.unsafeToForeign({

99+ errors: [ {

100+ message: v1.value0

101+ } ]

102+ }))({

103+ status: 400

104+ }));

105+ };

106+ if (v1 instanceof Data_Either.Right) {

107+ return bind1(run(Prospero_Http.executeRequest(schema)(v1.value0)))(function (resp) {

108+ return liftEffect(jsonResponse(Prospero_ResponseValue.responseValueToForeign(Prospero_GraphQLError.responseToResponseValue(resp)))({}));

109+ });

110+ };

111+ throw new Error("Failed pattern match at Prospero.Bun (line 84, column 7 - line 88, column 102): " + [ v1.constructor.name ]);

112+ };

113+ throw new Error("Failed pattern match at Prospero.Bun (line 80, column 3 - line 88, column 102): " + [ v.constructor.name ]);

114+ });

115+ };

116+ };

117+};

118+var handleGet = function (schema) {

119+ return function (run) {

120+ return function (req) {

121+ var v = Yoga_Bun_HTTP.requestSearchParam(req)("query");

122+ if (v instanceof Data_Maybe.Nothing) {

123+ return liftEffect(jsonResponse(Foreign.unsafeToForeign({

124+ errors: [ {

125+ message: "Missing query parameter"

126+ } ]

127+ }))({

128+ status: 400

129+ }));

130+ };

131+ if (v instanceof Data_Maybe.Just) {

132+ var operationName = Yoga_Bun_HTTP.requestSearchParam(req)("operationName");

133+ var gqlReq = {

134+ query: v.value0,

135+ operationName: operationName,

136+ variables: Data_Maybe.Nothing.value

137+ };

138+ return bind1(run(Prospero_Http.executeRequest(schema)(gqlReq)))(function (resp) {

139+ return liftEffect(jsonResponse(Prospero_ResponseValue.responseValueToForeign(Prospero_GraphQLError.responseToResponseValue(resp)))({}));

140+ });

141+ };

142+ throw new Error("Failed pattern match at Prospero.Bun (line 97, column 3 - line 103, column 98): " + [ v.constructor.name ]);

143+ };

144+ };

145+};

146+var fetchHandler = function (schema) {

147+ return function (run) {

148+ return function (reqF) {

149+ return function (serverF) {

150+ return fromAff((function () {

151+ var method = Yoga_Bun_HTTP.requestMethod(reqF);

152+ var $27 = upgradeRequested(reqF);

153+ if ($27) {

154+ return liftEffect(function __do() {

155+ upgrade(serverF)(reqF)();

156+ return Data_Unit.unit;

157+ });

158+ };

159+ if (method === "POST") {

160+ return handlePost(schema)(run)(reqF);

161+ };

162+ if (method === "GET") {

163+ return handleGet(schema)(run)(reqF);

164+ };

165+ return liftEffect(jsonResponse(Foreign.unsafeToForeign({

166+ errors: [ {

167+ message: "Method not allowed"

168+ } ]

169+ }))({

170+ status: 405

171+ }));

172+ })());

173+ };

174+ };

175+ };

176+};

177+var serve = function (schema) {

178+ return function (run) {

179+ return function (onSubscribe) {

180+ return function (opts) {

181+ return function __do() {

182+ var callbacksRef = Effect_Ref["new"](Data_Maybe.Nothing.value)();

183+ return serve1({

184+ port: opts.port,

185+ fetch: Effect_Uncurried.mkEffectFn2(fetchHandler(schema)(run)),

186+ websocket: {

187+ open: Effect_Uncurried.mkEffectFn1(wsOpen(schema)(run)(onSubscribe)(callbacksRef)),

188+ message: Effect_Uncurried.mkEffectFn2(wsMessage(callbacksRef)),

189+ close: Effect_Uncurried.mkEffectFn2(wsClose(callbacksRef))

190+ }

191+ })();

192+ };

193+ };

194+ };

195+ };

196+};

197+export {

198+ serve

199+};

output-compile-fail/Prospero.BunServe/externs.cbornew file

Binary file not shown.

output-compile-fail/Prospero.BunServe/foreign.jsnew file+6

@@ -0,0 +1,6 @@

1+export const serveImpl = (opts) => Bun.serve(opts);

2+export const stopImpl = (server) => server.stop();

3+export const portImpl = (server) => server.port;

4+export const upgradeImpl = (req, data, server) => server.upgrade(req, { data });

5+export const wsDataImpl = (ws) => ws.data;

6+export const setWsDataImpl = (ws, data) => { ws.data = data; };

output-compile-fail/Prospero.BunServe/index.jsnew file+25

@@ -0,0 +1,25 @@

1+// Generated by purs version 0.15.15

2+import * as $foreign from "./foreign.js";

3+import * as Effect_Uncurried from "../Effect.Uncurried/index.js";

4+var wsData = /* #__PURE__ */ Effect_Uncurried.runEffectFn1($foreign.wsDataImpl);

5+var upgrade = function (req) {

6+ return function (d) {

7+ return function (server) {

8+ return function () {

9+ return $foreign.upgradeImpl(req, d, server);

10+ };

11+ };

12+ };

13+};

14+var stop = /* #__PURE__ */ Effect_Uncurried.runEffectFn1($foreign.stopImpl);

15+var setWsData = /* #__PURE__ */ Effect_Uncurried.runEffectFn2($foreign.setWsDataImpl);

16+var serve = /* #__PURE__ */ Effect_Uncurried.runEffectFn1($foreign.serveImpl);

17+var port = /* #__PURE__ */ Effect_Uncurried.runEffectFn1($foreign.portImpl);

18+export {

19+ serve,

20+ stop,

21+ port,

22+ upgrade,

23+ wsData,

24+ setWsData

25+};

output-compile-fail/Prospero.Client.GqlUnion/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Client.GqlUnion/index.js+11−36

@@ -15,8 +15,6 @@ import * as Foreign_Index from "../Foreign.Index/index.js";

1515import * as Type_Proxy from "../Type.Proxy/index.js";

1616import * as Yoga_JSON from "../Yoga.JSON/index.js";

1717var fail = /* #__PURE__ */ Foreign.fail(Data_Identity.monadIdentity);

18−var on1 = /* #__PURE__ */ Data_Variant.on();

19−var match1 = /* #__PURE__ */ Data_Variant.match()()();

2018var alt = /* #__PURE__ */ Control_Alt.alt(/* #__PURE__ */ Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity));

2119var bind = /* #__PURE__ */ Control_Bind.bind(/* #__PURE__ */ Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity));

2220var readProp = /* #__PURE__ */ Foreign_Index.readProp(Data_Identity.monadIdentity);

@@ -26,6 +24,9 @@ var inj = /* #__PURE__ */ Data_Variant.inj();

2624var GqlUnion = function (x) {

2725 return x;

2826};

27+var showGqlUnion = function (dictShow) {

28+ return dictShow;

29+};

2930var readGqlUnionNil = {

3031 readGqlUnionImpl: function (v) {

3132 return function (v1) {

@@ -38,6 +39,9 @@ var newtypeGqlUnionVariant = {

3839 return undefined;

3940 }

4041};

42+var eqGqlUnion = function (dictEq) {

43+ return dictEq;

44+};

4145var readGqlUnionImpl = function (dict) {

4246 return dict.readGqlUnionImpl;

4347};

@@ -51,31 +55,6 @@ var readForeignGqlUnion = function () {

5155 };

5256 };

5357};

54−var on = function () {

55− return function (dictIsSymbol) {

56− var on2 = on1(dictIsSymbol);

57− return function (f) {

58− return function (g) {

59− return function (v) {

60− return on2(Type_Proxy["Proxy"].value)(f)(function ($54) {

61− return g(GqlUnion($54));

62− })(v);

63− };

64− };

65− };

66− };

67−};

68−var match = function () {

69− return function () {

70− return function () {

71− return function (handlers) {

72− return function (v) {

73− return match1(handlers)(v);

74− };

75− };

76− };

77− };

78−};

7958var lowercaseFirst = function (s) {

8059 var v = Data_String_CodeUnits.uncons(s);

8160 if (v instanceof Data_Maybe.Nothing) {

@@ -84,7 +63,7 @@ var lowercaseFirst = function (s) {

8463 if (v instanceof Data_Maybe.Just) {

8564 return Data_String_Common.toLower(Data_String_CodeUnits.singleton(v.value0.head)) + v.value0.tail;

8665 };

87− throw new Error("Failed pattern match at Prospero.Client.GqlUnion (line 30, column 20 - line 32, column 69): " + [ v.constructor.name ]);

66+ throw new Error("Failed pattern match at Prospero.Client.GqlUnion (line 25, column 20 - line 27, column 69): " + [ v.constructor.name ]);

8867};

8968var readGqlUnionCons = function (dictIsSymbol) {

9069 var reflectSymbol = Data_Symbol.reflectSymbol(dictIsSymbol);

@@ -98,8 +77,8 @@ var readGqlUnionCons = function (dictIsSymbol) {

9877 readGqlUnionImpl: function (v) {

9978 return function (o) {

10079 return alt(readGqlUnionImpl1(Type_Proxy["Proxy"].value)(o))(bind(bind(readProp("__typename")(o))(readImpl))(function (typeName) {

101− var $51 = lowercaseFirst(typeName) === reflectSymbol(Type_Proxy["Proxy"].value);

102− if ($51) {

80+ var $40 = lowercaseFirst(typeName) === reflectSymbol(Type_Proxy["Proxy"].value);

81+ if ($40) {

10382 return bind(readImpl1(o))(function (v1) {

10483 return pure(inj1(Type_Proxy["Proxy"].value)(v1));

10584 });

@@ -113,16 +92,12 @@ var readGqlUnionCons = function (dictIsSymbol) {

11392 };

11493 };

11594};

116−var case_ = function (v) {

117− return Data_Variant.case_(v);

118−};

11995export {

12096 GqlUnion,

12197 readGqlUnionImpl,

122− match,

123− on,

124− case_,

12598 newtypeGqlUnionVariant,

99+ showGqlUnion,

100+ eqGqlUnion,

126101 readForeignGqlUnion,

127102 readGqlUnionNil,

128103 readGqlUnionCons

output-compile-fail/Prospero.Client.WebSocket/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Client.WebSocket/foreign.js+4−6

@@ -1,11 +1,9 @@

1−import WebSocket from "ws";

2−

31export const connectImpl = (url) => (onOpen) => (onMessage) => (onClose) => (onError) => () => {

42 const ws = new WebSocket(url, ["graphql-transport-ws"]);

5− ws.on("open", () => onOpen());

6− ws.on("message", (data) => onMessage(data.toString())());

7− ws.on("close", () => onClose());

8− ws.on("error", (err) => onError(err.message)());

3+ ws.addEventListener("open", () => onOpen(ws)());

4+ ws.addEventListener("message", (event) => onMessage(typeof event.data === "string" ? event.data : event.data.toString())());

5+ ws.addEventListener("close", () => onClose());

6+ ws.addEventListener("error", (err) => onError(err.message || "WebSocket error")());

97 return ws;

108};

119

output-compile-fail/Prospero.Client/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Client/index.js+211−96

@@ -26,7 +26,6 @@ import * as Fetch_Internal_RequestBody from "../Fetch.Internal.RequestBody/index

2626import * as Foreign from "../Foreign/index.js";

2727import * as Prospero_Client_GqlUnion from "../Prospero.Client.GqlUnion/index.js";

2828import * as Prospero_Client_WebSocket from "../Prospero.Client.WebSocket/index.js";

29−import * as Ref_Lifted from "../Ref.Lifted/index.js";

3029import * as Type_Proxy from "../Type.Proxy/index.js";

3130import * as Yoga_JSON from "../Yoga.JSON/index.js";

3231var writeForeignRecord = /* #__PURE__ */ Yoga_JSON.writeForeignRecord();

@@ -75,8 +74,6 @@ var readJSON_2 = /* #__PURE__ */ Yoga_JSON.readJSON_(/* #__PURE__ */ readForeign

7574})(Yoga_JSON.readForeignString)(Yoga_JSON.readForeignFieldsNilRowRo)()())))(Yoga_JSON.readForeignFieldsNilRowRo)()()));

7675var bind2 = /* #__PURE__ */ Control_Bind.bind(Control_Bind.bindArray);

7776var intercalate = /* #__PURE__ */ Data_Array.intercalate(Data_Monoid.monoidString);

78−var $$new = /* #__PURE__ */ Ref_Lifted["new"](Effect_Aff.monadEffectAff);

79−var read = /* #__PURE__ */ Ref_Lifted.read(Effect_Class.monadEffectEffect);

8077var writeForeignFieldsCons = /* #__PURE__ */ Yoga_JSON.writeForeignFieldsCons(typeIsSymbol)(Yoga_JSON.writeForeignString)(Yoga_JSON.writeForeignFieldsNilRowR)()()();

8178var writeJSON1 = /* #__PURE__ */ Yoga_JSON.writeJSON(/* #__PURE__ */ writeForeignRecord(writeForeignFieldsCons));

8279var $$void = /* #__PURE__ */ Data_Functor["void"](Effect_Aff.functorAff);

@@ -84,7 +81,6 @@ var pure1 = /* #__PURE__ */ Control_Applicative.pure(Effect.applicativeEffect);

8481var liftEffect = /* #__PURE__ */ Effect_Class.liftEffect(Effect_Aff.monadEffectAff);

8582var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit);

8683var discard1 = /* #__PURE__ */ discard(Effect_Aff.bindAff);

87−var write = /* #__PURE__ */ Ref_Lifted.write(Effect_Aff.monadEffectAff);

8884var writeForeignFieldsCons1 = /* #__PURE__ */ Yoga_JSON.writeForeignFieldsCons({

8985 reflectSymbol: function () {

9086 return "id";

@@ -201,6 +197,19 @@ var unwrapFieldArray = function () {

201197 return {};

202198};

203199var unwrapField = {};

200+var unionResultConsNil = {};

201+var unionResultConsConsGqlUni = function () {

202+ return {};

203+};

204+var skipSpacesGo$34$bslashx0d$34 = function () {

205+ return {};

206+};

207+var skipSpacesGo$34$bslashx0a$34 = function () {

208+ return {};

209+};

210+var skipSpacesGo$34$bslashx09$34 = function () {

211+ return {};

212+};

204213var skipSpacesGo$34$32$34 = function () {

205214 return {};

206215};

@@ -272,6 +281,21 @@ var scalarResultBooleanBoolea = {};

272281var scalarResult = {};

273282var recordRowRecord = {};

274283var parseGqlUnionNestedGo$34$125$34 = {};

284+var parseGqlUnionNestedGo$34$bslashx0 = function () {

285+ return function () {

286+ return {};

287+ };

288+};

289+var parseGqlUnionNestedGo$34$bslashx01 = function () {

290+ return function () {

291+ return {};

292+ };

293+};

294+var parseGqlUnionNestedGo$34$bslashx02 = function () {

295+ return function () {

296+ return {};

297+ };

298+};

275299var parseGqlUnionNestedGo$34$dot$34 = function () {

276300 return function () {

277301 return function () {

@@ -390,6 +414,21 @@ var parseGqlNestedGo$34$123$34 = function () {

390414 };

391415 };

392416};

417+var parseGqlNestedGo$34$bslashx0d$34 = function () {

418+ return function () {

419+ return {};

420+ };

421+};

422+var parseGqlNestedGo$34$bslashx0a$34 = function () {

423+ return function () {

424+ return {};

425+ };

426+};

427+var parseGqlNestedGo$34$bslashx09$34 = function () {

428+ return function () {

429+ return {};

430+ };

431+};

393432var parseGqlNestedGo$34$colon$34 = function () {

394433 return function () {

395434 return function () {

@@ -483,6 +522,21 @@ var parseGqlNestedAliasedFiel6 = function () {

483522 return {};

484523 };

485524};

525+var parseGqlNestedAliasedFiel7 = function () {

526+ return function () {

527+ return {};

528+ };

529+};

530+var parseGqlNestedAliasedFiel8 = function () {

531+ return function () {

532+ return {};

533+ };

534+};

535+var parseGqlNestedAliasedFiel9 = function () {

536+ return function () {

537+ return {};

538+ };

539+};

486540var parseGqlNestedAliasedAfte = function () {

487541 return function () {

488542 return {};

@@ -587,6 +641,21 @@ var parseGqlNested = function () {

587641 return {};

588642 };

589643};

644+var parseGqlLiteralSkip$34$bslashx0d$34 = function () {

645+ return function () {

646+ return {};

647+ };

648+};

649+var parseGqlLiteralSkip$34$bslashx0a$34 = function () {

650+ return function () {

651+ return {};

652+ };

653+};

654+var parseGqlLiteralSkip$34$bslashx09$34 = function () {

655+ return function () {

656+ return {};

657+ };

658+};

590659var parseGqlLiteralSkip$34$44$34 = function () {

591660 return function () {

592661 return {};

@@ -633,6 +702,21 @@ var parseGqlGo$34$123$34 = function () {

633702 };

634703 };

635704};

705+var parseGqlGo$34$bslashx0d$34 = function () {

706+ return function () {

707+ return {};

708+ };

709+};

710+var parseGqlGo$34$bslashx0a$34 = function () {

711+ return function () {

712+ return {};

713+ };

714+};

715+var parseGqlGo$34$bslashx09$34 = function () {

716+ return function () {

717+ return {};

718+ };

719+};

636720var parseGqlGo$34$colon$34 = function () {

637721 return function () {

638722 return function () {

@@ -690,10 +774,12 @@ var parseGqlChildByKindUnitRe = function () {

690774 };

691775 };

692776};

693−var parseGqlChildByKindUnionG = function (dictGeneric) {

777+var parseGqlChildByKindUnion = function () {

694778 return function () {

695779 return function () {

696− return {};

780+ return function () {

781+ return {};

782+ };

697783 };

698784 };

699785};

@@ -719,6 +805,21 @@ var parseGqlArgsStart = function () {

719805 return {};

720806 };

721807};

808+var parseGqlArgsGo$34$bslashx0d$34 = function () {

809+ return function () {

810+ return {};

811+ };

812+};

813+var parseGqlArgsGo$34$bslashx0a$34 = function () {

814+ return function () {

815+ return {};

816+ };

817+};

818+var parseGqlArgsGo$34$bslashx09$34 = function () {

819+ return function () {

820+ return {};

821+ };

822+};

722823var parseGqlArgsGo$34$colon$34 = function () {

723824 return function () {

724825 return {};

@@ -804,6 +905,21 @@ var parseGqlAliasedFieldGo$34$123$34 = function () {

804905 };

805906 };

806907};

908+var parseGqlAliasedFieldGo$34$bslashx = function () {

909+ return function () {

910+ return {};

911+ };

912+};

913+var parseGqlAliasedFieldGo$34$bslashx1 = function () {

914+ return function () {

915+ return {};

916+ };

917+};

918+var parseGqlAliasedFieldGo$34$bslashx2 = function () {

919+ return function () {

920+ return {};

921+ };

922+};

807923var parseGqlAliasedFieldGo$34$40$34 = function () {

808924 return function () {

809925 return function () {

@@ -946,6 +1062,9 @@ var parseGql = function () {

9461062var parseFragmentTypeNameGo$34$123 = function () {

9471063 return {};

9481064};

1065+var parseFragmentTypeNameGo$34$bslash = {};

1066+var parseFragmentTypeNameGo$34$bslash1 = {};

1067+var parseFragmentTypeNameGo$34$bslash2 = {};

9491068var parseFragmentTypeNameGo$34$34 = function () {

9501069 return {};

9511070};

@@ -963,10 +1082,6 @@ var parseFragmentTypeName = function () {

9631082 return {};

9641083 };

9651084};

966−var matchOrContinue = function () {

967− return {};

968−};

969−var matchOrContinue1 = {};

9701085var lowercaseFirst = function () {

9711086 return function () {

9721087 return function () {

@@ -1001,22 +1116,11 @@ var lowercaseChar$34C$34$34c$34 = {};

10011116var lowercaseChar$34B$34$34b$34 = {};

10021117var lowercaseChar$34A$34$34a$34 = {};

10031118var lowercaseChar = {};

1004−var findUnionMemberSum = function () {

1119+var findVariantMemberNil = undefined;

1120+var findVariantMemberCons = function () {

10051121 return {};

10061122};

1007−var findUnionMemberMatch = undefined;

1008−var findUnionMemberMatch1 = {};

1009−var findUnionMemberInSum = function () {

1010− return function () {

1011− return {};

1012− };

1013−};

1014−var findUnionMemberConstructo = function () {

1015− return function () {

1016− return {};

1017− };

1018−};

1019−var findUnionMember = undefined;

1123+var findVariantMemberCons1 = {};

10201124var findFieldNil = undefined;

10211125var findFieldCons = function () {

10221126 return {};

@@ -1027,12 +1131,6 @@ var findArgCons = function () {

10271131 return {};

10281132};

10291133var findArgCons1 = {};

1030−var extractMemberNameSum = function () {

1031− return {};

1032−};

1033−var extractMemberNameConstruc = function () {

1034− return {};

1035−};

10361134var extractArgsSubscriptionRo = {};

10371135var extractArgsRow = {};

10381136var extractArgsQueryUnitRow = {};

@@ -1052,7 +1150,7 @@ var childKind = function () {

10521150var assertNonEmpty$34$34 = undefined;

10531151var assertNonEmpty = {};

10541152var runSelectionWith = function (dictReadForeign) {

1055− var read1 = Yoga_JSON.read(dictReadForeign);

1153+ var read = Yoga_JSON.read(dictReadForeign);

10561154 return function (dictWriteForeign) {

10571155 return function (prefix) {

10581156 return function (url) {

@@ -1069,7 +1167,7 @@ var runSelectionWith = function (dictReadForeign) {

10691167 }

10701168 }))(function (v1) {

10711169 return bind(v1.json)(function (foreign_) {

1072− var v2 = read1(foreign_);

1170+ var v2 = read(foreign_);

10731171 if (v2 instanceof Data_Either.Left) {

10741172 return throwError(Effect_Exception.error(show(v2.value0)));

10751173 };

@@ -1090,10 +1188,10 @@ var runSelectionWith = function (dictReadForeign) {

10901188 message: "No data returned"

10911189 }));

10921190 };

1093− throw new Error("Failed pattern match at Prospero.Client (line 120, column 12 - line 124, column 94): " + [ v2.value0.data.constructor.name, v3.constructor.name ]);

1191+ throw new Error("Failed pattern match at Prospero.Client (line 118, column 12 - line 122, column 94): " + [ v2.value0.data.constructor.name, v3.constructor.name ]);

10941192 })());

10951193 };

1096− throw new Error("Failed pattern match at Prospero.Client (line 117, column 3 - line 124, column 94): " + [ v2.constructor.name ]);

1194+ throw new Error("Failed pattern match at Prospero.Client (line 115, column 3 - line 122, column 94): " + [ v2.constructor.name ]);

10971195 });

10981196 });

10991197 };

@@ -1115,9 +1213,9 @@ var runMutationSelection = function (dictReadForeign) {

11151213 };

11161214};

11171215var renderArgs = function (dictWriteForeign) {

1118− var $472 = Yoga_JSON.writeJSON(dictWriteForeign);

1119− return function ($473) {

1120− return $foreign.jsonToGraphQLArgs($472($473));

1216+ var $489 = Yoga_JSON.writeJSON(dictWriteForeign);

1217+ return function ($490) {

1218+ return $foreign.jsonToGraphQLArgs($489($490));

11211219 };

11221220};

11231221var withArgs = function (dictWriteForeign) {

@@ -1144,7 +1242,7 @@ var recoverPartialSuccess = function (v) {

11441242 if (v instanceof Failure) {

11451243 return Data_Maybe.Nothing.value;

11461244 };

1147− throw new Error("Failed pattern match at Prospero.Client (line 45, column 1 - line 45, column 110): " + [ v.constructor.name ]);

1245+ throw new Error("Failed pattern match at Prospero.Client (line 43, column 1 - line 43, column 110): " + [ v.constructor.name ]);

11481246};

11491247var parseServerMessage = function (str) {

11501248 return bind1(readJSON_(str))(function (v) {

@@ -1165,7 +1263,7 @@ var parseServerMessage = function (str) {

11651263 if (v2 instanceof Data_Maybe.Nothing) {

11661264 return new Data_Maybe.Just(new ServerError("Unknown error"));

11671265 };

1168− throw new Error("Failed pattern match at Prospero.Client (line 235, column 7 - line 237, column 54): " + [ v2.constructor.name ]);

1266+ throw new Error("Failed pattern match at Prospero.Client (line 229, column 7 - line 231, column 54): " + [ v2.constructor.name ]);

11691267 });

11701268 };

11711269 if (v.type === "complete") {

@@ -1245,7 +1343,7 @@ var subscribe = function () {

12451343 return function () {

12461344 return function (dictWriteForeign) {

12471345 return function (dictReadForeign) {

1248− var read1 = Yoga_JSON.read(dictReadForeign);

1346+ var read = Yoga_JSON.read(dictReadForeign);

12491347 return function (dictIsSymbol) {

12501348 var subscriptionSelection2 = subscriptionSelection1(dictIsSymbol);

12511349 return function (url) {

@@ -1253,55 +1351,50 @@ var subscribe = function () {

12531351 return function (callback) {

12541352 var query = "subscription " + $foreign.substituteParams(subscriptionSelection2)(params);

12551353 return bind(Effect_Aff_AVar.empty)(function (ackVar) {

1256− return bind($$new(Data_Unit.unit))(function (wsRef) {

1257− var onOpen = function __do() {

1258− var ws = read(wsRef)();

1259− return Prospero_Client_WebSocket.send(ws)(writeJSON1({

1260− type: "connection_init"

1261− }))();

1354+ var onOpen = function (ws$prime) {

1355+ return Prospero_Client_WebSocket.send(ws$prime)(writeJSON1({

1356+ type: "connection_init"

1357+ }));

1358+ };

1359+ var onMessage = function (msg) {

1360+ var v1 = parseServerMessage(msg);

1361+ if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof ConnectionAck) {

1362+ return Effect_Aff.launchAff_($$void(Effect_Aff_AVar.tryPut(Data_Unit.unit)(ackVar)));

12621363 };

1263− var onMessage = function (msg) {

1264− var v1 = parseServerMessage(msg);

1265− if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof ConnectionAck) {

1266− return Effect_Aff.launchAff_($$void(Effect_Aff_AVar.tryPut(Data_Unit.unit)(ackVar)));

1267− };

1268− if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof Next) {

1269− var v2 = read1(v1.value0.value0);

1270− if (v2 instanceof Data_Either.Right) {

1271− return callback(new Success(v2.value0));

1272− };

1273− if (v2 instanceof Data_Either.Left) {

1274− return pure1(Data_Unit.unit);

1275− };

1276− throw new Error("Failed pattern match at Prospero.Client (line 205, column 9 - line 207, column 30): " + [ v2.constructor.name ]);

1364+ if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof Next) {

1365+ var v2 = read(v1.value0.value0);

1366+ if (v2 instanceof Data_Either.Right) {

1367+ return callback(new Success(v2.value0));

12771368 };

1278− if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof ServerError) {

1279− return callback(new Failure(Data_Array_NonEmpty.singleton({

1280− message: v1.value0.value0

1281− })));

1369+ if (v2 instanceof Data_Either.Left) {

1370+ return pure1(Data_Unit.unit);

12821371 };

1283− return pure1(Data_Unit.unit);

1372+ throw new Error("Failed pattern match at Prospero.Client (line 200, column 9 - line 202, column 30): " + [ v2.constructor.name ]);

1373+ };

1374+ if (v1 instanceof Data_Maybe.Just && v1.value0 instanceof ServerError) {

1375+ return callback(new Failure(Data_Array_NonEmpty.singleton({

1376+ message: v1.value0.value0

1377+ })));

12841378 };

1285− return bind(liftEffect(Prospero_Client_WebSocket.connect(url)(onOpen)(onMessage)(pure1(Data_Unit.unit))(function (v1) {

1286− return pure1(Data_Unit.unit);

1287− })))(function (ws) {

1288− return discard1(write(ws)(wsRef))(function () {

1289− return discard1(Effect_Aff_AVar.take(ackVar))(function () {

1290− return discard1(liftEffect(Prospero_Client_WebSocket.send(ws)(writeJSON2({

1291− type: "subscribe",

1292− id: "1",

1293− payload: {

1294− query: query

1295− }

1296− }))))(function () {

1297− return pure(function __do() {

1298− Prospero_Client_WebSocket.send(ws)(writeJSON3({

1299− type: "complete",

1300− id: "1"

1301− }))();

1302− return Prospero_Client_WebSocket.close(ws)();

1303− });

1304− });

1379+ return pure1(Data_Unit.unit);

1380+ };

1381+ return bind(liftEffect(Prospero_Client_WebSocket.connect(url)(onOpen)(onMessage)(pure1(Data_Unit.unit))(function (v1) {

1382+ return pure1(Data_Unit.unit);

1383+ })))(function (ws) {

1384+ return discard1(Effect_Aff_AVar.take(ackVar))(function () {

1385+ return discard1(liftEffect(Prospero_Client_WebSocket.send(ws)(writeJSON2({

1386+ type: "subscribe",

1387+ id: "1",

1388+ payload: {

1389+ query: query

1390+ }

1391+ }))))(function () {

1392+ return pure(function __do() {

1393+ Prospero_Client_WebSocket.send(ws)(writeJSON3({

1394+ type: "complete",

1395+ id: "1"

1396+ }))();

1397+ return Prospero_Client_WebSocket.close(ws)();

13051398 });

13061399 });

13071400 });

@@ -1390,6 +1483,9 @@ export {

13901483 parseGqlTrimmed$34$34NilNil,

13911484 parseGqlTrimmed,

13921485 parseGqlGo$34$32$34,

1486+ parseGqlGo$34$bslashx0a$34,

1487+ parseGqlGo$34$bslashx09$34,

1488+ parseGqlGo$34$bslashx0d$34,

13931489 parseGqlGo$34$44$34,

13941490 parseGqlGo$34$40$34,

13951491 parseGqlGo$34$123$34,

@@ -1408,6 +1504,9 @@ export {

14081504 parseGqlNestedGo$34$125$34$34$34,

14091505 parseGqlNestedGo$34$125$34Cons,

14101506 parseGqlNestedGo$34$32$34,

1507+ parseGqlNestedGo$34$bslashx0a$34,

1508+ parseGqlNestedGo$34$bslashx09$34,

1509+ parseGqlNestedGo$34$bslashx0d$34,

14111510 parseGqlNestedGo$34$44$34,

14121511 parseGqlNestedGo$34$40$34,

14131512 parseGqlNestedGo$34$123$34,

@@ -1431,6 +1530,9 @@ export {

14311530 parseGqlAfterArgs$34$34Cons,

14321531 parseGqlAfterArgs,

14331532 parseGqlAliasedFieldGo$34$32$34,

1533+ parseGqlAliasedFieldGo$34$bslashx2,

1534+ parseGqlAliasedFieldGo$34$bslashx1,

1535+ parseGqlAliasedFieldGo$34$bslashx,

14341536 parseGqlAliasedFieldGo$34$40$34,

14351537 parseGqlAliasedFieldGo$34$123$34,

14361538 parseGqlAliasedFieldGo$34$34C,

@@ -1442,6 +1544,9 @@ export {

14421544 parseGqlAliasedAfterSpace,

14431545 parseGqlAliasedAfterArgs$34,

14441546 parseGqlAliasedAfterArgs,

1547+ parseGqlNestedAliasedFiel9,

1548+ parseGqlNestedAliasedFiel8,

1549+ parseGqlNestedAliasedFiel7,

14451550 parseGqlNestedAliasedFiel6,

14461551 parseGqlNestedAliasedFiel5,

14471552 parseGqlNestedAliasedFiel4,

@@ -1467,6 +1572,9 @@ export {

14671572 parseGqlArgsGo$34$41$34$34$34,

14681573 parseGqlArgsGo$34$colon$34,

14691574 parseGqlArgsGo$34$32$34,

1575+ parseGqlArgsGo$34$bslashx0a$34,

1576+ parseGqlArgsGo$34$bslashx09$34,

1577+ parseGqlArgsGo$34$bslashx0d$34,

14701578 parseGqlArgsGo,

14711579 parseGqlArgsColon$34$34,

14721580 parseGqlArgsColon,

@@ -1495,6 +1603,9 @@ export {

14951603 parseGqlLiteralSkip$34$41$34,

14961604 parseGqlLiteralSkip$34$44$34,

14971605 parseGqlLiteralSkip$34$32$34,

1606+ parseGqlLiteralSkip$34$bslashx0a$34,

1607+ parseGqlLiteralSkip$34$bslashx09$34,

1608+ parseGqlLiteralSkip$34$bslashx0d$34,

14981609 parseGqlLiteralSkip$34$34,

14991610 parseGqlLiteralSkip,

15001611 parseGqlLiteralSep$34$34,

@@ -1543,7 +1654,9 @@ export {

15431654 childKindRecordUnit,

15441655 childKind,

15451656 parseGqlChild,

1546− parseGqlChildByKindUnionG,

1657+ unionResultConsNil,

1658+ unionResultConsConsGqlUni,

1659+ parseGqlChildByKindUnion,

15471660 parseGqlChildByKindUnitRe,

15481661 parseGqlChildByKindRecord,

15491662 lowercaseFirst,

@@ -1574,20 +1687,16 @@ export {

15741687 lowercaseChar$34Y$34$34y$34,

15751688 lowercaseChar$34Z$34$34z$34,

15761689 lowercaseChar,

1577− findUnionMemberConstructo,

1578− findUnionMemberSum,

1579− findUnionMember,

1580− findUnionMemberMatch1,

1581− findUnionMemberMatch,

1582− findUnionMemberInSum,

1583− extractMemberNameConstruc,

1584− extractMemberNameSum,

1585− matchOrContinue1,

1586− matchOrContinue,

1690+ findVariantMemberCons1,

1691+ findVariantMemberCons,

1692+ findVariantMemberNil,

15871693 parseGqlUnionNested$34$34,

15881694 parseGqlUnionNested,

15891695 parseGqlUnionNestedGo$34$125$34,

15901696 parseGqlUnionNestedGo$34$32$34,

1697+ parseGqlUnionNestedGo$34$bslashx02,

1698+ parseGqlUnionNestedGo$34$bslashx01,

1699+ parseGqlUnionNestedGo$34$bslashx0,

15911700 parseGqlUnionNestedGo$34$dot$34,

15921701 parseGqlUnionNestedGo,

15931702 parseGqlUnionBrace$34$34,

@@ -1609,6 +1718,9 @@ export {

16091718 parseFragmentTypeName$34$34,

16101719 parseFragmentTypeName,

16111720 parseFragmentTypeNameGo$34$32,

1721+ parseFragmentTypeNameGo$34$bslash2,

1722+ parseFragmentTypeNameGo$34$bslash1,

1723+ parseFragmentTypeNameGo$34$bslash,

16121724 parseFragmentTypeNameGo$34$123,

16131725 parseFragmentTypeNameGo$34$34,

16141726 parseFragmentTypeNameGo,

@@ -1617,6 +1729,9 @@ export {

16171729 skipSpaces$34$34$34$34,

16181730 skipSpaces,

16191731 skipSpacesGo$34$32$34,

1732+ skipSpacesGo$34$bslashx0a$34,

1733+ skipSpacesGo$34$bslashx09$34,

1734+ skipSpacesGo$34$bslashx0d$34,

16201735 skipSpacesGo

16211736};

16221737export {

output-compile-fail/Prospero.Codegen.Main/externs.cbornew file

Binary file not shown.

output-compile-fail/Prospero.Codegen.Main/index.jsnew file+26

@@ -0,0 +1,26 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array from "../Data.Array/index.js";

3+import * as Effect_Console from "../Effect.Console/index.js";

4+import * as Node_Encoding from "../Node.Encoding/index.js";

5+import * as Node_FS_Sync from "../Node.FS.Sync/index.js";

6+import * as Node_Process from "../Node.Process/index.js";

7+import * as Prospero_Codegen from "../Prospero.Codegen/index.js";

8+var main = function __do() {

9+ var args = Node_Process.argv();

10+ var v = Data_Array.drop(2)(args);

11+ if (v.length === 3) {

12+ var sdl = Node_FS_Sync.readTextFile(Node_Encoding.UTF8.value)(v[0])();

13+ var result = Prospero_Codegen.generateModule(v[1])(sdl);

14+ Node_FS_Sync.writeTextFile(Node_Encoding.UTF8.value)(v[2])(result)();

15+ return Effect_Console.log("Generated " + v[2])();

16+ };

17+ if (v.length === 2) {

18+ var sdl = Node_FS_Sync.readTextFile(Node_Encoding.UTF8.value)(v[0])();

19+ var result = Prospero_Codegen.generateModule(v[1])(sdl);

20+ return Effect_Console.log(result)();

21+ };

22+ return Effect_Console.error("Usage: prospero-codegen <schema.graphql> <Module.Name> [output.purs]")();

23+};

24+export {

25+ main

26+};

output-compile-fail/Prospero.Codegen/externs.cbornew file

Binary file not shown.

output-compile-fail/Prospero.Codegen/foreign.jsnew file+56

@@ -0,0 +1,56 @@

1+import { buildSchema, introspectionFromSchema } from "graphql";

2+import * as Maybe from "../Data.Maybe/index.js";

3+

4+const toMaybe = (v) => v == null ? Maybe.Nothing.value : Maybe.Just.create(v);

5+

6+const convertTypeRef = (ref) => {

7+ if (!ref) return null;

8+ return {

9+ name: toMaybe(ref.name),

10+ kind: ref.kind,

11+ ofType: toMaybe(ref.ofType ? convertTypeRef(ref.ofType) : null),

12+ };

13+};

14+

15+const convertField = (f) => ({

16+ name: f.name,

17+ type: convertTypeRef(f.type),

18+ args: (f.args || []).map(convertInputValue),

19+ description: toMaybe(f.description),

20+ isDeprecated: f.isDeprecated || false,

21+ deprecationReason: toMaybe(f.deprecationReason),

22+});

23+

24+const convertInputValue = (iv) => ({

25+ name: iv.name,

26+ type: convertTypeRef(iv.type),

27+ description: toMaybe(iv.description),

28+ defaultValue: toMaybe(iv.defaultValue),

29+});

30+

31+const convertType = (t) => ({

32+ name: toMaybe(t.name),

33+ kind: t.kind,

34+ fields: toMaybe(t.fields ? t.fields.map(convertField) : null),

35+ description: toMaybe(t.description),

36+ enumValues: toMaybe(t.enumValues ? t.enumValues.map((v) => ({

37+ name: v.name,

38+ description: toMaybe(v.description),

39+ isDeprecated: v.isDeprecated || false,

40+ deprecationReason: toMaybe(v.deprecationReason),

41+ })) : null),

42+ possibleTypes: toMaybe(t.possibleTypes ? t.possibleTypes.map((pt) => ({ name: pt.name })) : null),

43+ inputFields: toMaybe(t.inputFields ? t.inputFields.map(convertInputValue) : null),

44+});

45+

46+export const introspectSDLImpl = (sdl) => {

47+ const schema = buildSchema(sdl);

48+ const result = introspectionFromSchema(schema);

49+ const s = result.__schema;

50+ return {

51+ types: s.types.map(convertType),

52+ queryType: toMaybe(s.queryType),

53+ mutationType: toMaybe(s.mutationType),

54+ subscriptionType: toMaybe(s.subscriptionType),

55+ };

56+};

output-compile-fail/Prospero.Codegen/index.jsnew file+549

@@ -0,0 +1,549 @@

1+// Generated by purs version 0.15.15

2+import * as $foreign from "./foreign.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Control_Apply from "../Control.Apply/index.js";

5+import * as Control_Bind from "../Control.Bind/index.js";

6+import * as Control_Monad_Free from "../Control.Monad.Free/index.js";

7+import * as Data_Array from "../Data.Array/index.js";

8+import * as Data_Eq from "../Data.Eq/index.js";

9+import * as Data_Functor from "../Data.Functor/index.js";

10+import * as Data_Maybe from "../Data.Maybe/index.js";

11+import * as Data_String_CodeUnits from "../Data.String.CodeUnits/index.js";

12+import * as Data_String_Common from "../Data.String.Common/index.js";

13+import * as Data_Tuple from "../Data.Tuple/index.js";

14+import * as Data_Unit from "../Data.Unit/index.js";

15+import * as Tidy_Codegen from "../Tidy.Codegen/index.js";

16+import * as Tidy_Codegen_Class from "../Tidy.Codegen.Class/index.js";

17+import * as Tidy_Codegen_Monad from "../Tidy.Codegen.Monad/index.js";

18+var toQualifiedNameString = /* #__PURE__ */ Tidy_Codegen_Class.toQualifiedNameString();

19+var binaryOp = /* #__PURE__ */ Tidy_Codegen.binaryOp(/* #__PURE__ */ toQualifiedNameString(Tidy_Codegen_Class.fromTokenQualifiedOperato));

20+var toQualifiedNameString1 = /* #__PURE__ */ toQualifiedNameString(Tidy_Codegen_Class.fromTokenQualifiedProper);

21+var typeCtor = /* #__PURE__ */ Tidy_Codegen.typeCtor(toQualifiedNameString1);

22+var elem = /* #__PURE__ */ Data_Array.elem(Data_Eq.eqString);

23+var typeRecord = /* #__PURE__ */ Tidy_Codegen.typeRecord(Tidy_Codegen_Class.toNameStringLabel);

24+var mapFlipped = /* #__PURE__ */ Data_Functor.mapFlipped(Data_Functor.functorArray);

25+var applySecond = /* #__PURE__ */ Control_Apply.applySecond(/* #__PURE__ */ Tidy_Codegen_Monad.applyCodegenT(Control_Monad_Free.freeMonad));

26+var pure = /* #__PURE__ */ Control_Applicative.pure(/* #__PURE__ */ Tidy_Codegen_Monad.applicativeCodegenT(Control_Monad_Free.freeMonad));

27+var typeCtor1 = /* #__PURE__ */ Tidy_Codegen.typeCtor(Tidy_Codegen_Class.toQualifiedNameQualifiedN);

28+var mapFlipped1 = /* #__PURE__ */ Data_Functor.mapFlipped(Data_Maybe.functorMaybe);

29+var eqMaybe = /* #__PURE__ */ Data_Maybe.eqMaybe(Data_Eq.eqString);

30+var elem1 = /* #__PURE__ */ Data_Array.elem(eqMaybe);

31+var eq = /* #__PURE__ */ Data_Eq.eq(Data_Eq.eqString);

32+var eq1 = /* #__PURE__ */ Data_Eq.eq(eqMaybe);

33+var codegenModule = /* #__PURE__ */ Tidy_Codegen_Monad.codegenModule(/* #__PURE__ */ Tidy_Codegen_Class.toNameStringModuleName());

34+var bindCodegenT = /* #__PURE__ */ Tidy_Codegen_Monad.bindCodegenT(Control_Monad_Free.freeMonad);

35+var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit)(bindCodegenT);

36+var toModuleNameString = /* #__PURE__ */ Tidy_Codegen_Class.toModuleNameString();

37+var importOpen = /* #__PURE__ */ Tidy_Codegen_Monad.importOpen(Control_Monad_Free.freeMonad)(toModuleNameString);

38+var bind = /* #__PURE__ */ Control_Bind.bind(bindCodegenT);

39+var importFrom = /* #__PURE__ */ Tidy_Codegen_Monad.importFrom(Control_Monad_Free.freeMonad)(toModuleNameString)(Tidy_Codegen_Monad.toImportFromImportNameQua);

40+var toTokenStringQualifiedPro = /* #__PURE__ */ Tidy_Codegen_Class.toTokenStringQualifiedPro();

41+var importType = /* #__PURE__ */ Tidy_Codegen_Monad.importType(toTokenStringQualifiedPro);

42+var importClass = /* #__PURE__ */ Tidy_Codegen_Monad.importClass(toTokenStringQualifiedPro);

43+var importValue = /* #__PURE__ */ Tidy_Codegen_Monad.importValue(/* #__PURE__ */ Tidy_Codegen_Class.toTokenStringQualifiedIde());

44+var importTypeOp = /* #__PURE__ */ Tidy_Codegen_Monad.importTypeOp(/* #__PURE__ */ Tidy_Codegen_Class.toTokenStringQualifiedSym());

45+var writeAndExport = /* #__PURE__ */ Tidy_Codegen_Monad.writeAndExport(Control_Monad_Free.freeMonad);

46+var toNameStringProper = /* #__PURE__ */ Tidy_Codegen_Class.toNameStringProper();

47+var declNewtype = /* #__PURE__ */ Tidy_Codegen.declNewtype(toNameStringProper)(toNameStringProper);

48+var write = /* #__PURE__ */ Tidy_Codegen_Monad.write(Control_Monad_Free.freeMonad);

49+var declDerive = /* #__PURE__ */ Tidy_Codegen.declDerive(toQualifiedNameString1);

50+var declInstance = /* #__PURE__ */ Tidy_Codegen.declInstance(Tidy_Codegen.declInstanceDeclaration)(toQualifiedNameString1);

51+var dataCtor = /* #__PURE__ */ Tidy_Codegen.dataCtor(toNameStringProper);

52+var declData = /* #__PURE__ */ Tidy_Codegen.declData(toNameStringProper);

53+var instValue = /* #__PURE__ */ Tidy_Codegen.instValue(/* #__PURE__ */ Tidy_Codegen_Class.toNameStringIdent())(Tidy_Codegen_Class.toGuardedExpr);

54+var binderCtor = /* #__PURE__ */ Tidy_Codegen.binderCtor(toQualifiedNameString1);

55+var exprIdent = /* #__PURE__ */ Tidy_Codegen.exprIdent(/* #__PURE__ */ toQualifiedNameString(Tidy_Codegen_Class.fromTokenQualifiedIdent));

56+var typeRow = /* #__PURE__ */ Tidy_Codegen.typeRow(Tidy_Codegen_Class.toNameStringLabel);

57+var declType = /* #__PURE__ */ Tidy_Codegen.declType(toNameStringProper);

58+var wrapMetadata = function (meta) {

59+ return function (baseType) {

60+ var ops = Data_Array.concat([ (function () {

61+ if (meta.isDeprecated && meta.deprecationReason instanceof Data_Maybe.Just) {

62+ return [ binaryOp("#")(Tidy_Codegen.typeApp(typeCtor("Deprecated"))([ Tidy_Codegen.typeString(meta.deprecationReason.value0) ])) ];

63+ };

64+ if (meta.isDeprecated && meta.deprecationReason instanceof Data_Maybe.Nothing) {

65+ return [ binaryOp("#")(Tidy_Codegen.typeApp(typeCtor("Deprecated"))([ Tidy_Codegen.typeString("") ])) ];

66+ };

67+ return [ ];

68+ })(), (function () {

69+ if (meta.description instanceof Data_Maybe.Just) {

70+ return [ binaryOp("#")(Tidy_Codegen.typeApp(typeCtor("Described"))([ Tidy_Codegen.typeString(meta.description.value0) ])) ];

71+ };

72+ if (meta.description instanceof Data_Maybe.Nothing) {

73+ return [ ];

74+ };

75+ throw new Error("Failed pattern match at Prospero.Codegen (line 172, column 11 - line 174, column 26): " + [ meta.description.constructor.name ]);

76+ })() ]);

77+ var v = Data_Array["null"](ops);

78+ if (v) {

79+ return baseType;

80+ };

81+ if (!v) {

82+ return Tidy_Codegen.typeOp(baseType)(ops);

83+ };

84+ throw new Error("Failed pattern match at Prospero.Codegen (line 176, column 3 - line 178, column 33): " + [ v.constructor.name ]);

85+ };

86+};

87+var wrapInputMetadata = function (iv) {

88+ return wrapMetadata({

89+ description: iv.description,

90+ isDeprecated: false,

91+ deprecationReason: Data_Maybe.Nothing.value

92+ });

93+};

94+var wrapFieldMetadata = function (f) {

95+ return wrapMetadata({

96+ description: f.description,

97+ isDeprecated: f.isDeprecated,

98+ deprecationReason: f.deprecationReason

99+ });

100+};

101+var refOfType = function (r) {

102+ return r.ofType;

103+};

104+var refName = function (r) {

105+ return r.name;

106+};

107+var refKind = function (r) {

108+ return r.kind;

109+};

110+var typeRefToType = function (ref) {

111+ var namedType = function (r) {

112+ var v = refName(r);

113+ if (v instanceof Data_Maybe.Just && v.value0 === "String") {

114+ return typeCtor("String");

115+ };

116+ if (v instanceof Data_Maybe.Just && v.value0 === "Int") {

117+ return typeCtor("Int");

118+ };

119+ if (v instanceof Data_Maybe.Just && v.value0 === "Float") {

120+ return typeCtor("Number");

121+ };

122+ if (v instanceof Data_Maybe.Just && v.value0 === "Boolean") {

123+ return typeCtor("Boolean");

124+ };

125+ if (v instanceof Data_Maybe.Just && v.value0 === "ID") {

126+ return typeCtor("ID");

127+ };

128+ if (v instanceof Data_Maybe.Just) {

129+ return typeCtor(v.value0);

130+ };

131+ if (v instanceof Data_Maybe.Nothing) {

132+ return typeCtor("Unit");

133+ };

134+ throw new Error("Failed pattern match at Prospero.Codegen (line 121, column 31 - line 128, column 31): " + [ v.constructor.name ]);

135+ };

136+ var nonNullType = function (inner) {

137+ var v = refKind(inner);

138+ if (v === "LIST") {

139+ var v1 = refOfType(inner);

140+ if (v1 instanceof Data_Maybe.Just) {

141+ return Tidy_Codegen.typeApp(typeCtor("Array"))([ typeRefToType(v1.value0) ]);

142+ };

143+ if (v1 instanceof Data_Maybe.Nothing) {

144+ return Tidy_Codegen.typeApp(typeCtor("Array"))([ typeCtor("Unit") ]);

145+ };

146+ throw new Error("Failed pattern match at Prospero.Codegen (line 116, column 15 - line 118, column 64): " + [ v1.constructor.name ]);

147+ };

148+ return namedType(inner);

149+ };

150+ var v = refKind(ref);

151+ if (v === "NON_NULL") {

152+ var v1 = refOfType(ref);

153+ if (v1 instanceof Data_Maybe.Just) {

154+ return nonNullType(v1.value0);

155+ };

156+ if (v1 instanceof Data_Maybe.Nothing) {

157+ return typeCtor("Unit");

158+ };

159+ throw new Error("Failed pattern match at Prospero.Codegen (line 107, column 17 - line 109, column 31): " + [ v1.constructor.name ]);

160+ };

161+ if (v === "LIST") {

162+ var v1 = refOfType(ref);

163+ if (v1 instanceof Data_Maybe.Just) {

164+ return Tidy_Codegen.typeApp(typeCtor("Maybe"))([ Tidy_Codegen.typeApp(typeCtor("Array"))([ typeRefToType(v1.value0) ]) ]);

165+ };

166+ if (v1 instanceof Data_Maybe.Nothing) {

167+ return Tidy_Codegen.typeApp(typeCtor("Maybe"))([ Tidy_Codegen.typeApp(typeCtor("Array"))([ typeCtor("Unit") ]) ]);

168+ };

169+ throw new Error("Failed pattern match at Prospero.Codegen (line 110, column 13 - line 112, column 93): " + [ v1.constructor.name ]);

170+ };

171+ return Tidy_Codegen.typeApp(typeCtor("Maybe"))([ namedType(ref) ]);

172+};

173+var namedTypeRef = function (r) {

174+ var v = refName(r);

175+ if (v instanceof Data_Maybe.Just && v.value0 === "String") {

176+ return typeCtor("String");

177+ };

178+ if (v instanceof Data_Maybe.Just && v.value0 === "Int") {

179+ return typeCtor("Int");

180+ };

181+ if (v instanceof Data_Maybe.Just && v.value0 === "Float") {

182+ return typeCtor("Number");

183+ };

184+ if (v instanceof Data_Maybe.Just && v.value0 === "Boolean") {

185+ return typeCtor("Boolean");

186+ };

187+ if (v instanceof Data_Maybe.Just && v.value0 === "ID") {

188+ return typeCtor("ID");

189+ };

190+ if (v instanceof Data_Maybe.Just) {

191+ return typeCtor(v.value0);

192+ };

193+ if (v instanceof Data_Maybe.Nothing) {

194+ return typeCtor("Unit");

195+ };

196+ throw new Error("Failed pattern match at Prospero.Codegen (line 150, column 32 - line 157, column 29): " + [ v.constructor.name ]);

197+};

198+var nonNullTypeRef = function ($copy_ref) {

199+ var $tco_done = false;

200+ var $tco_result;

201+ function $tco_loop(ref) {

202+ var v = refKind(ref);

203+ if (v === "NON_NULL") {

204+ var v1 = refOfType(ref);

205+ if (v1 instanceof Data_Maybe.Just) {

206+ $copy_ref = v1.value0;

207+ return;

208+ };

209+ if (v1 instanceof Data_Maybe.Nothing) {

210+ $tco_done = true;

211+ return typeCtor("Unit");

212+ };

213+ throw new Error("Failed pattern match at Prospero.Codegen (line 141, column 17 - line 143, column 31): " + [ v1.constructor.name ]);

214+ };

215+ if (v === "LIST") {

216+ var v1 = refOfType(ref);

217+ if (v1 instanceof Data_Maybe.Just) {

218+ $tco_done = true;

219+ return Tidy_Codegen.typeApp(typeCtor("Array"))([ typeRefToType(v1.value0) ]);

220+ };

221+ if (v1 instanceof Data_Maybe.Nothing) {

222+ $tco_done = true;

223+ return Tidy_Codegen.typeApp(typeCtor("Array"))([ typeCtor("Unit") ]);

224+ };

225+ throw new Error("Failed pattern match at Prospero.Codegen (line 144, column 13 - line 146, column 62): " + [ v1.constructor.name ]);

226+ };

227+ $tco_done = true;

228+ return namedTypeRef(ref);

229+ };

230+ while (!$tco_done) {

231+ $tco_result = $tco_loop($copy_ref);

232+ };

233+ return $tco_result;

234+};

235+var inputValueTypeRef = function (iv) {

236+ return iv.type;

237+};

238+var fieldTypeRef = function (f) {

239+ return f.type;

240+};

241+var capitalize = function (s) {

242+ var v = Data_String_CodeUnits.uncons(s);

243+ if (v instanceof Data_Maybe.Just) {

244+ return Data_String_Common.toUpper(Data_String_CodeUnits.singleton(v.value0.head)) + v.value0.tail;

245+ };

246+ if (v instanceof Data_Maybe.Nothing) {

247+ return s;

248+ };

249+ throw new Error("Failed pattern match at Prospero.Codegen (line 99, column 16 - line 101, column 15): " + [ v.constructor.name ]);

250+};

251+var builtinTypes = [ "String", "Int", "Float", "Boolean", "ID", "__Schema", "__Type", "__Field", "__InputValue", "__EnumValue", "__Directive", "__DirectiveLocation", "__TypeKind" ];

252+var isBuiltin = function (name) {

253+ return elem(name)(builtinTypes);

254+};

255+var argsToType = function (args) {

256+ var argToField = function (arg) {

257+ if (arg.defaultValue instanceof Data_Maybe.Just) {

258+ return new Data_Tuple.Tuple(arg.name, Tidy_Codegen.typeApp(typeCtor("Defaulted"))([ Tidy_Codegen.typeString(arg.defaultValue.value0), nonNullTypeRef(inputValueTypeRef(arg)) ]));

259+ };

260+ if (arg.defaultValue instanceof Data_Maybe.Nothing) {

261+ return new Data_Tuple.Tuple(arg.name, typeRefToType(inputValueTypeRef(arg)));

262+ };

263+ throw new Error("Failed pattern match at Prospero.Codegen (line 135, column 34 - line 137, column 70): " + [ arg.defaultValue.constructor.name ]);

264+ };

265+ var $121 = Data_Array["null"](args);

266+ if ($121) {

267+ return typeCtor("Unit");

268+ };

269+ return typeRecord(mapFlipped(args)(argToField))(Data_Maybe.Nothing.value);

270+};

271+var generateModule = function (moduleName) {

272+ return function (sdl) {

273+ var traverse_ = function (xs) {

274+ return function (f) {

275+ return Data_Array.foldl(function (acc) {

276+ return function (x) {

277+ return applySecond(acc)(f(x));

278+ };

279+ })(pure(Data_Unit.unit))(xs);

280+ };

281+ };

282+ var rootFields = function (wrapper) {

283+ return function (hasArgs) {

284+ return function (t) {

285+ var fields = Data_Maybe.fromMaybe([ ])(t.fields);

286+ return mapFlipped(fields)(function (f) {

287+ var resultType = typeRefToType(fieldTypeRef(f));

288+ var wrappedType = (function () {

289+ if (hasArgs) {

290+ var argType = argsToType(f.args);

291+ return Tidy_Codegen.typeApp(typeCtor1(wrapper))([ argType, resultType ]);

292+ };

293+ return Tidy_Codegen.typeApp(typeCtor1(wrapper))([ resultType ]);

294+ })();

295+ return new Data_Tuple.Tuple(f.name, wrapFieldMetadata(f)(wrappedType));

296+ });

297+ };

298+ };

299+ };

300+ var schema = $foreign.introspectSDLImpl(sdl);

301+ var queryName = mapFlipped1(schema.queryType)(function (v) {

302+ return v.name;

303+ });

304+ var mutationName = mapFlipped1(schema.mutationType)(function (v) {

305+ return v.name;

306+ });

307+ var subscriptionName = mapFlipped1(schema.subscriptionType)(function (v) {

308+ return v.name;

309+ });

310+ var isRootType = function (name) {

311+ return elem1(new Data_Maybe.Just(name))([ queryName, mutationName, subscriptionName ]);

312+ };

313+ var userTypes = Data_Array.filter(function (t) {

314+ if (t.name instanceof Data_Maybe.Just) {

315+ return !isBuiltin(t.name.value0) && !isRootType(t.name.value0);

316+ };

317+ if (t.name instanceof Data_Maybe.Nothing) {

318+ return false;

319+ };

320+ throw new Error("Failed pattern match at Prospero.Codegen (line 189, column 53 - line 191, column 25): " + [ t.name.constructor.name ]);

321+ })(schema.types);

322+ var scalars = Data_Array.filter((function () {

323+ var $137 = eq("SCALAR");

324+ return function ($138) {

325+ return $137((function (v) {

326+ return v.kind;

327+ })($138));

328+ };

329+ })())(userTypes);

330+ var enums = Data_Array.filter((function () {

331+ var $139 = eq("ENUM");

332+ return function ($140) {

333+ return $139((function (v) {

334+ return v.kind;

335+ })($140));

336+ };

337+ })())(userTypes);

338+ var objects = Data_Array.filter((function () {

339+ var $141 = eq("OBJECT");

340+ return function ($142) {

341+ return $141((function (v) {

342+ return v.kind;

343+ })($142));

344+ };

345+ })())(userTypes);

346+ var unions = Data_Array.filter((function () {

347+ var $143 = eq("UNION");

348+ return function ($144) {

349+ return $143((function (v) {

350+ return v.kind;

351+ })($144));

352+ };

353+ })())(userTypes);

354+ var inputObjects = Data_Array.filter((function () {

355+ var $145 = eq("INPUT_OBJECT");

356+ return function ($146) {

357+ return $145((function (v) {

358+ return v.kind;

359+ })($146));

360+ };

361+ })())(userTypes);

362+ var interfaces = Data_Array.filter((function () {

363+ var $147 = eq("INTERFACE");

364+ return function ($148) {

365+ return $147((function (v) {

366+ return v.kind;

367+ })($148));

368+ };

369+ })())(userTypes);

370+ var queryType = Data_Array.find(function (t) {

371+ return eq1(t.name)(queryName);

372+ })(schema.types);

373+ var mutationType = Data_Array.find(function (t) {

374+ return eq1(t.name)(mutationName);

375+ })(schema.types);

376+ var subscriptionType = Data_Array.find(function (t) {

377+ return eq1(t.name)(subscriptionName);

378+ })(schema.types);

379+ return Tidy_Codegen.printModule(codegenModule(moduleName)(discard(importOpen("Prelude"))(function () {

380+ return bind(importFrom("Data.Maybe")(importType("Maybe")))(function () {

381+ return bind(importFrom("Data.Generic.Rep")(importClass("Generic")))(function () {

382+ return bind(importFrom("Data.Newtype")(importClass("Newtype")))(function () {

383+ return bind(importFrom("Data.Variant")(importType("Variant")))(function () {

384+ return bind(importFrom("Prospero.Metadata")(importClass("IsGql")))(function () {

385+ return bind(importFrom("Prospero.Metadata")(importType("Object")))(function () {

386+ return bind(importFrom("Prospero.Metadata")(importType("Enum")))(function () {

387+ return bind(importFrom("Prospero.Metadata")(importType("Union")))(function () {

388+ return bind(importFrom("Prospero.Metadata")(importType("Scalar")))(function () {

389+ return bind(importFrom("Prospero.Metadata")(importType("InputObject")))(function () {

390+ return bind(importFrom("Prospero.Metadata")(importType("Interface")))(function () {

391+ return bind(importFrom("Prospero.Scalars")(importType("ID")))(function () {

392+ return bind(importFrom("Prospero.InputValue")(importClass("FromInputValue")))(function () {

393+ return bind(importFrom("Prospero.Schema")(importValue("genericFromInputValue")))(function () {

394+ return bind(importFrom("Prospero.Schema")(importValue("newtypeFromInputValue")))(function () {

395+ return bind(importFrom("Prospero.GqlQuery")(importType("Query")))(function (gqlQuery) {

396+ return bind(importFrom("Prospero.GqlQuery")(importType("Mutation")))(function (gqlMutation) {

397+ return bind(importFrom("Prospero.GqlQuery")(importType("Subscription")))(function (gqlSubscription) {

398+ return bind(importFrom("Prospero.Metadata")(importType("Described")))(function () {

399+ return bind(importFrom("Prospero.Metadata")(importType("Deprecated")))(function () {

400+ return bind(importFrom("Prospero.Metadata")(importType("Defaulted")))(function () {

401+ return bind(importFrom("Type.Function")(importTypeOp("#")))(function () {

402+ return discard(traverse_(scalars)(function (t) {

403+ if (t.name instanceof Data_Maybe.Just) {

404+ return discard(writeAndExport(declNewtype(t.name.value0)([ ])(t.name.value0)(typeCtor("String"))))(function () {

405+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Newtype")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

406+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("Scalar"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ]));

407+ });

408+ });

409+ };

410+ if (t.name instanceof Data_Maybe.Nothing) {

411+ return pure(Data_Unit.unit);

412+ };

413+ throw new Error("Failed pattern match at Prospero.Codegen (line 229, column 29 - line 234, column 27): " + [ t.name.constructor.name ]);

414+ }))(function () {

415+ return discard(traverse_(enums)(function (t) {

416+ if (t.name instanceof Data_Maybe.Just) {

417+ var values = mapFlipped(Data_Maybe.fromMaybe([ ])(t.enumValues))(function (v) {

418+ return v.name;

419+ });

420+ var ctors = mapFlipped(values)(function (v) {

421+ return dataCtor(capitalize(Data_String_Common.toLower(v)))([ ]);

422+ });

423+ return discard(writeAndExport(declData(t.name.value0)([ ])(ctors)))(function () {

424+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Generic")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

425+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Eq")([ typeCtor(t.name.value0) ])))(function () {

426+ return discard(write(declInstance(Data_Maybe.Nothing.value)([ ])("Show")([ typeCtor(t.name.value0) ])(mapFlipped(values)(function (v) {

427+ return instValue("show")([ binderCtor(capitalize(Data_String_Common.toLower(v)))([ ]) ])(Tidy_Codegen.exprString(v));

428+ }))))(function () {

429+ return discard(write(declInstance(Data_Maybe.Nothing.value)([ ])("FromInputValue")([ typeCtor(t.name.value0) ])([ instValue("fromInputValue")([ ])(exprIdent("genericFromInputValue")) ])))(function () {

430+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("Enum"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ]));

431+ });

432+ });

433+ });

434+ });

435+ });

436+ };

437+ if (t.name instanceof Data_Maybe.Nothing) {

438+ return pure(Data_Unit.unit);

439+ };

440+ throw new Error("Failed pattern match at Prospero.Codegen (line 237, column 27 - line 252, column 27): " + [ t.name.constructor.name ]);

441+ }))(function () {

442+ return discard(traverse_(objects)(function (t) {

443+ if (t.name instanceof Data_Maybe.Just) {

444+ var fields = Data_Maybe.fromMaybe([ ])(t.fields);

445+ var recFields = mapFlipped(fields)(function (f) {

446+ return new Data_Tuple.Tuple(f.name, wrapFieldMetadata(f)(typeRefToType(fieldTypeRef(f))));

447+ });

448+ return discard(writeAndExport(declNewtype(t.name.value0)([ ])(t.name.value0)(typeRecord(recFields)(Data_Maybe.Nothing.value))))(function () {

449+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Newtype")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

450+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("Object"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ]));

451+ });

452+ });

453+ };

454+ if (t.name instanceof Data_Maybe.Nothing) {

455+ return pure(Data_Unit.unit);

456+ };

457+ throw new Error("Failed pattern match at Prospero.Codegen (line 255, column 29 - line 262, column 27): " + [ t.name.constructor.name ]);

458+ }))(function () {

459+ return discard(traverse_(inputObjects)(function (t) {

460+ if (t.name instanceof Data_Maybe.Just) {

461+ var fields = Data_Maybe.fromMaybe([ ])(t.inputFields);

462+ var recFields = mapFlipped(fields)(function (f) {

463+ return new Data_Tuple.Tuple(f.name, wrapInputMetadata(f)(typeRefToType(inputValueTypeRef(f))));

464+ });

465+ return discard(writeAndExport(declNewtype(t.name.value0)([ ])(t.name.value0)(typeRecord(recFields)(Data_Maybe.Nothing.value))))(function () {

466+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Newtype")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

467+ return discard(write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("InputObject"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ])))(function () {

468+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("FromInputValue")([ typeCtor(t.name.value0) ])([ instValue("fromInputValue")([ ])(exprIdent("newtypeFromInputValue")) ]));

469+ });

470+ });

471+ });

472+ };

473+ if (t.name instanceof Data_Maybe.Nothing) {

474+ return pure(Data_Unit.unit);

475+ };

476+ throw new Error("Failed pattern match at Prospero.Codegen (line 265, column 34 - line 274, column 27): " + [ t.name.constructor.name ]);

477+ }))(function () {

478+ return discard(traverse_(interfaces)(function (t) {

479+ if (t.name instanceof Data_Maybe.Just) {

480+ var fields = Data_Maybe.fromMaybe([ ])(t.fields);

481+ var recFields = mapFlipped(fields)(function (f) {

482+ return new Data_Tuple.Tuple(f.name, wrapFieldMetadata(f)(typeRefToType(fieldTypeRef(f))));

483+ });

484+ return discard(writeAndExport(declNewtype(t.name.value0)([ ])(t.name.value0)(typeRecord(recFields)(Data_Maybe.Nothing.value))))(function () {

485+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Newtype")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

486+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("Interface"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ]));

487+ });

488+ });

489+ };

490+ if (t.name instanceof Data_Maybe.Nothing) {

491+ return pure(Data_Unit.unit);

492+ };

493+ throw new Error("Failed pattern match at Prospero.Codegen (line 277, column 32 - line 284, column 27): " + [ t.name.constructor.name ]);

494+ }))(function () {

495+ return discard(traverse_(unions)(function (t) {

496+ if (t.name instanceof Data_Maybe.Just) {

497+ var members = mapFlipped(Data_Maybe.fromMaybe([ ])(t.possibleTypes))(function (v) {

498+ return v.name;

499+ });

500+ var variantRow = typeRow(mapFlipped(members)(function (m) {

501+ return new Data_Tuple.Tuple(m, typeCtor(m));

502+ }))(Data_Maybe.Nothing.value);

503+ return discard(writeAndExport(declNewtype(t.name.value0)([ ])(t.name.value0)(Tidy_Codegen.typeParens(Tidy_Codegen.typeApp(typeCtor("Variant"))([ variantRow ])))))(function () {

504+ return discard(write(declDerive(Data_Maybe.Nothing.value)([ ])("Newtype")([ typeCtor(t.name.value0), Tidy_Codegen.typeWildcard ])))(function () {

505+ return write(declInstance(Data_Maybe.Nothing.value)([ ])("IsGql")([ typeCtor("Union"), Tidy_Codegen.typeString(t.name.value0), typeCtor(t.name.value0) ])([ ]));

506+ });

507+ });

508+ };

509+ if (t.name instanceof Data_Maybe.Nothing) {

510+ return pure(Data_Unit.unit);

511+ };

512+ throw new Error("Failed pattern match at Prospero.Codegen (line 287, column 28 - line 294, column 27): " + [ t.name.constructor.name ]);

513+ }))(function () {

514+ var schemaFields = Data_Array.concat([ Data_Maybe.maybe([ ])(rootFields(gqlQuery)(true))(queryType), Data_Maybe.maybe([ ])(rootFields(gqlMutation)(true))(mutationType), Data_Maybe.maybe([ ])(rootFields(gqlSubscription)(false))(subscriptionType) ]);

515+ return writeAndExport(declType("Schema")([ ])(typeRecord(schemaFields)(Data_Maybe.Nothing.value)));

516+ });

517+ });

518+ });

519+ });

520+ });

521+ });

522+ });

523+ });

524+ });

525+ });

526+ });

527+ });

528+ });

529+ });

530+ });

531+ });

532+ });

533+ });

534+ });

535+ });

536+ });

537+ });

538+ });

539+ });

540+ });

541+ });

542+ });

543+ });

544+ })));

545+ };

546+};

547+export {

548+ generateModule

549+};

output-compile-fail/Prospero.GraphQLWS/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.GraphQLWS/index.js+45−43

@@ -64,11 +64,11 @@ var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit);

6464var discard1 = /* #__PURE__ */ discard(Effect_Aff.bindAff);

6565var liftEffect = /* #__PURE__ */ Effect_Class.liftEffect(Effect_Aff.monadEffectAff);

6666var $$new = /* #__PURE__ */ Ref_Lifted["new"](Effect_Class.monadEffectEffect);

67+var pure = /* #__PURE__ */ Control_Applicative.pure(Effect.applicativeEffect);

6768var writeJSON3 = /* #__PURE__ */ Yoga_JSON.writeJSON(/* #__PURE__ */ writeForeignRecord(writeForeignFieldsCons2));

6869var read = /* #__PURE__ */ Ref_Lifted.read(Effect_Class.monadEffectEffect);

6970var lookup = /* #__PURE__ */ Data_Map_Internal.lookup(Data_Ord.ordString);

7071var $$delete = /* #__PURE__ */ Data_Map_Internal["delete"](Data_Ord.ordString);

71−var pure = /* #__PURE__ */ Control_Applicative.pure(Effect.applicativeEffect);

7272var traverse_ = /* #__PURE__ */ Data_Foldable.traverse_(Effect.applicativeEffect)(Data_List_Types.foldableList);

7373var identity = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);

7474var write = /* #__PURE__ */ Ref_Lifted.write(Effect_Class.monadEffectEffect);

@@ -114,7 +114,7 @@ var selFieldName = function (v) {

114114 if (v instanceof Prospero_Execution.FieldWithArgs) {

115115 return v.value0.fieldName;

116116 };

117− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 117, column 16 - line 119, column 39): " + [ v.constructor.name ]);

117+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 118, column 16 - line 120, column 39): " + [ v.constructor.name ]);

118118};

119119var selChildren = function (v) {

120120 if (v instanceof Prospero_Execution.Field) {

@@ -123,7 +123,7 @@ var selChildren = function (v) {

123123 if (v instanceof Prospero_Execution.FieldWithArgs) {

124124 return v.value2;

125125 };

126− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 122, column 15 - line 124, column 33): " + [ v.constructor.name ]);

126+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 123, column 15 - line 125, column 33): " + [ v.constructor.name ]);

127127};

128128var responseToInput = function (v) {

129129 if (v instanceof Prospero_ResponseValue.StringValue) {

@@ -150,7 +150,7 @@ var responseToInput = function (v) {

150150 if (v instanceof Prospero_ResponseValue.ObjectValue) {

151151 return new Prospero_InputValue.InputObject(fromFoldable(toUnfoldable(map1(responseToInput)(v.value0))));

152152 };

153− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 162, column 19 - line 170, column 107): " + [ v.constructor.name ]);

153+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 163, column 19 - line 171, column 107): " + [ v.constructor.name ]);

154154};

155155var parseMessage = function (str) {

156156 return bind(map2(Prospero_ResponseValue.foreignToResponseValue)(Data_Either.hush(Control_Monad_Except.runExcept(Yoga_JSON.parseJSON(str)))))(function (parsed) {

@@ -262,7 +262,7 @@ var handleSubscribe = function (schema) {

262262 if (payload.variables instanceof Data_Maybe.Just) {

263263 return payload.variables.value0;

264264 };

265− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 81, column 12 - line 83, column 18): " + [ payload.variables.constructor.name ]);

265+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 82, column 12 - line 84, column 18): " + [ payload.variables.constructor.name ]);

266266 })();

267267 var v = Prospero_Parser.parseOperation(payload.query)(vars);

268268 if (v instanceof Data_Either.Left) {

@@ -292,7 +292,7 @@ var handleSubscribe = function (schema) {

292292 });

293293 }));

294294 };

295− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 84, column 3 - line 104, column 52): " + [ v.constructor.name ]);

295+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 85, column 3 - line 105, column 52): " + [ v.constructor.name ]);

296296 };

297297 };

298298 };

@@ -306,45 +306,47 @@ var handleGraphQLWS = function (schema) {

306306 return function (ws) {

307307 return function __do() {

308308 var subs = $$new(Data_Map_Internal.empty)();

309− Prospero_WebSocket.onMessage(ws)(function (msg) {

310− var v = parseMessage(msg);

311− if (v instanceof Data_Maybe.Just && v.value0 instanceof ConnectionInit) {

312− return Prospero_WebSocket.send(ws)(writeJSON3({

313− type: "connection_ack"

314− }));

315− };

316− if (v instanceof Data_Maybe.Just && v.value0 instanceof Ping) {

317− return Prospero_WebSocket.send(ws)(writeJSON3({

318− type: "pong"

319− }));

320− };

321− if (v instanceof Data_Maybe.Just && v.value0 instanceof Subscribe) {

322− return handleSubscribe(schema)(run)(onSubscribe)(ws)(subs)(v.value0.value0)(v.value0.value1);

323− };

324− if (v instanceof Data_Maybe.Just && v.value0 instanceof Complete) {

325− return function __do() {

326− var currentSubs = read(subs)();

327− var v1 = lookup(v.value0.value0)(currentSubs);

328− if (v1 instanceof Data_Maybe.Just) {

329− v1.value0();

330− return modify($$delete(v.value0.value0))(subs)();

331− };

332− if (v1 instanceof Data_Maybe.Nothing) {

333− return Data_Unit.unit;

309+ return {

310+ onMessage: function (msg) {

311+ var v = parseMessage(msg);

312+ if (v instanceof Data_Maybe.Just && v.value0 instanceof ConnectionInit) {

313+ return Prospero_WebSocket.send(ws)(writeJSON3({

314+ type: "connection_ack"

315+ }));

316+ };

317+ if (v instanceof Data_Maybe.Just && v.value0 instanceof Ping) {

318+ return Prospero_WebSocket.send(ws)(writeJSON3({

319+ type: "pong"

320+ }));

321+ };

322+ if (v instanceof Data_Maybe.Just && v.value0 instanceof Subscribe) {

323+ return handleSubscribe(schema)(run)(onSubscribe)(ws)(subs)(v.value0.value0)(v.value0.value1);

324+ };

325+ if (v instanceof Data_Maybe.Just && v.value0 instanceof Complete) {

326+ return function __do() {

327+ var currentSubs = read(subs)();

328+ var v1 = lookup(v.value0.value0)(currentSubs);

329+ if (v1 instanceof Data_Maybe.Just) {

330+ v1.value0();

331+ return modify($$delete(v.value0.value0))(subs)();

332+ };

333+ if (v1 instanceof Data_Maybe.Nothing) {

334+ return Data_Unit.unit;

335+ };

336+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 58, column 13 - line 62, column 35): " + [ v1.constructor.name ]);

334337 };

335− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 58, column 9 - line 62, column 31): " + [ v1.constructor.name ]);

336338 };

337− };

338− if (v instanceof Data_Maybe.Nothing) {

339− return pure(Data_Unit.unit);

340− };

341− throw new Error("Failed pattern match at Prospero.GraphQLWS (line 49, column 5 - line 63, column 27): " + [ v.constructor.name ]);

342− })();

343− return Prospero_WebSocket.onClose(ws)(function __do() {

344− var currentSubs = read(subs)();

345− traverse_(identity)(Data_Map_Internal.values(currentSubs))();

346− return write(Data_Map_Internal.empty)(subs)();

347− })();

339+ if (v instanceof Data_Maybe.Nothing) {

340+ return pure(Data_Unit.unit);

341+ };

342+ throw new Error("Failed pattern match at Prospero.GraphQLWS (line 49, column 9 - line 63, column 31): " + [ v.constructor.name ]);

343+ },

344+ onClose: function __do() {

345+ var currentSubs = read(subs)();

346+ traverse_(identity)(Data_Map_Internal.values(currentSubs))();

347+ return write(Data_Map_Internal.empty)(subs)();

348+ }

349+ };

348350 };

349351 };

350352 };

output-compile-fail/Prospero.InputValue/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.InputValue/index.js+12−3

@@ -27,11 +27,11 @@ var compare3 = /* #__PURE__ */ Data_Ord.compare(Data_Ord.ordBoolean);

2727var ordMap = /* #__PURE__ */ Data_Map_Internal.ordMap(Data_Ord.ordString);

2828var traverse = /* #__PURE__ */ Data_Traversable.traverse(Data_Traversable.traversableArray)(Data_Either.applicativeEither);

2929var map = /* #__PURE__ */ Data_Functor.map(Data_Either.functorEither);

30+var wrap = /* #__PURE__ */ Data_Newtype.wrap();

3031var bind = /* #__PURE__ */ Control_Bind.bind(Data_Either.bindEither);

3132var lookup = /* #__PURE__ */ Data_Map_Internal.lookup(Data_Ord.ordString);

3233var lmap = /* #__PURE__ */ Data_Bifunctor.lmap(Data_Bifunctor.bifunctorEither);

3334var insert = /* #__PURE__ */ Record_Builder.insert()();

34−var wrap = /* #__PURE__ */ Data_Newtype.wrap();

3535var InputString = /* #__PURE__ */ (function () {

3636 function InputString(value0) {

3737 this.value0 = value0;

@@ -164,7 +164,7 @@ var showInputValue = {

164164 if (v instanceof InputNull) {

165165 return "InputNull";

166166 };

167− throw new Error("Failed pattern match at Prospero.InputValue (line 33, column 10 - line 41, column 29): " + [ v.constructor.name ]);

167+ throw new Error("Failed pattern match at Prospero.InputValue (line 34, column 10 - line 42, column 29): " + [ v.constructor.name ]);

168168 }

169169};

170170var show4 = /* #__PURE__ */ Data_Show.show(showInputValue);

@@ -182,7 +182,7 @@ var showInputError = {

182182 if (v instanceof UnknownEnumValue) {

183183 return "Unknown enum value '" + (v.value0 + "'");

184184 };

185− throw new Error("Failed pattern match at Prospero.InputValue (line 52, column 10 - line 56, column 69): " + [ v.constructor.name ]);

185+ throw new Error("Failed pattern match at Prospero.InputValue (line 53, column 10 - line 57, column 69): " + [ v.constructor.name ]);

186186 }

187187};

188188var fromInputValueString = {

@@ -380,6 +380,14 @@ var fromInputValueArray = function (dictFromInputValue) {

380380 }

381381 };

382382};

383+var fromInputValueDefaulted = function (dictFromInputValue) {

384+ var fromInputValue1 = fromInputValue(dictFromInputValue);

385+ return {

386+ fromInputValue: function (v) {

387+ return map(wrap)(fromInputValue1(v));

388+ }

389+ };

390+};

383391var fromInputValueMaybe = function (dictFromInputValue) {

384392 var fromInputValue1 = fromInputValue(dictFromInputValue);

385393 return {

@@ -481,6 +489,7 @@ export {

481489 fromInputValueBoolean,

482490 fromInputValueMaybe,

483491 fromInputValueArray,

492+ fromInputValueDefaulted,

484493 fromInputValueRecord,

485494 fromInputRecordNilRow,

486495 fromInputRecordCons

output-compile-fail/Prospero.Metadata/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Metadata/index.js+102

@@ -26,6 +26,9 @@ var Described = function (x) {

2626var Deprecated = function (x) {

2727 return x;

2828};

29+var Defaulted = function (x) {

30+ return x;

31+};

2932var Cost = function (x) {

3033 return x;

3134};

@@ -64,6 +67,11 @@ var newtypeDeprecated_ = {

6467 return undefined;

6568 }

6669};

70+var newtypeDefaulted_ = {

71+ Coercible0: function () {

72+ return undefined;

73+ }

74+};

6775var newtypeCost_ = {

6876 Coercible0: function () {

6977 return undefined;

@@ -118,6 +126,19 @@ var hasGqlDeprecated = {

118126 return Data_Maybe.Nothing.value;

119127 }

120128};

129+var hasGqlDefaultValueDefault = function (dictIsSymbol) {

130+ var reflectSymbol = Data_Symbol.reflectSymbol(dictIsSymbol);

131+ return {

132+ gqlDefaultValue: function (v) {

133+ return new Data_Maybe.Just(reflectSymbol(Type_Proxy["Proxy"].value));

134+ }

135+ };

136+};

137+var hasGqlDefaultValue = {

138+ gqlDefaultValue: function (v) {

139+ return Data_Maybe.Nothing.value;

140+ }

141+};

121142var hasGqlCostCost = function (dictReflectable) {

122143 var reflectType = Data_Reflectable.reflectType(dictReflectable);

123144 return {

@@ -165,6 +186,14 @@ var hasGqlNameCost = function (dictHasGqlName) {

165186 }

166187 };

167188};

189+var hasGqlNameDefaulted = function (dictHasGqlName) {

190+ var gqlFieldName1 = gqlFieldName(dictHasGqlName);

191+ return {

192+ gqlFieldName: function (v) {

193+ return gqlFieldName1(Type_Proxy["Proxy"].value);

194+ }

195+ };

196+};

168197var hasGqlNameDeprecated = function (dictHasGqlName) {

169198 var gqlFieldName1 = gqlFieldName(dictHasGqlName);

170199 return {

@@ -203,6 +232,14 @@ var gqlExcluded = function (dict) {

203232var gqlDescription = function (dict) {

204233 return dict.gqlDescription;

205234};

235+var hasGqlDescriptionDefaulte = function (dictHasGqlDescription) {

236+ var gqlDescription1 = gqlDescription(dictHasGqlDescription);

237+ return {

238+ gqlDescription: function (v) {

239+ return gqlDescription1(Type_Proxy["Proxy"].value);

240+ }

241+ };

242+};

206243var hasGqlDescriptionNamed = function (dictHasGqlDescription) {

207244 var gqlDescription1 = gqlDescription(dictHasGqlDescription);

208245 return {

@@ -214,6 +251,14 @@ var hasGqlDescriptionNamed = function (dictHasGqlDescription) {

214251var gqlDeprecationReason = function (dict) {

215252 return dict.gqlDeprecationReason;

216253};

254+var hasGqlDeprecatedDefaulted = function (dictHasGqlDeprecated) {

255+ var gqlDeprecationReason1 = gqlDeprecationReason(dictHasGqlDeprecated);

256+ return {

257+ gqlDeprecationReason: function (v) {

258+ return gqlDeprecationReason1(Type_Proxy["Proxy"].value);

259+ }

260+ };

261+};

217262var hasGqlDeprecatedNamed = function (dictHasGqlDeprecated) {

218263 var gqlDeprecationReason1 = gqlDeprecationReason(dictHasGqlDeprecated);

219264 return {

@@ -222,9 +267,44 @@ var hasGqlDeprecatedNamed = function (dictHasGqlDeprecated) {

222267 }

223268 };

224269};

270+var gqlDefaultValue = function (dict) {

271+ return dict.gqlDefaultValue;

272+};

273+var hasGqlDefaultValueDepreca = function (dictHasGqlDefaultValue) {

274+ var gqlDefaultValue1 = gqlDefaultValue(dictHasGqlDefaultValue);

275+ return {

276+ gqlDefaultValue: function (v) {

277+ return gqlDefaultValue1(Type_Proxy["Proxy"].value);

278+ }

279+ };

280+};

281+var hasGqlDefaultValueDescrib = function (dictHasGqlDefaultValue) {

282+ var gqlDefaultValue1 = gqlDefaultValue(dictHasGqlDefaultValue);

283+ return {

284+ gqlDefaultValue: function (v) {

285+ return gqlDefaultValue1(Type_Proxy["Proxy"].value);

286+ }

287+ };

288+};

289+var hasGqlDefaultValueNamed = function (dictHasGqlDefaultValue) {

290+ var gqlDefaultValue1 = gqlDefaultValue(dictHasGqlDefaultValue);

291+ return {

292+ gqlDefaultValue: function (v) {

293+ return gqlDefaultValue1(Type_Proxy["Proxy"].value);

294+ }

295+ };

296+};

225297var gqlCost = function (dict) {

226298 return dict.gqlCost;

227299};

300+var hasGqlCostDefaulted = function (dictHasGqlCost) {

301+ var gqlCost1 = gqlCost(dictHasGqlCost);

302+ return {

303+ gqlCost: function (v) {

304+ return gqlCost1(Type_Proxy["Proxy"].value);

305+ }

306+ };

307+};

228308var hasGqlCostDeprecated = function (dictHasGqlCost) {

229309 var gqlCost1 = gqlCost(dictHasGqlCost);

230310 return {

@@ -260,6 +340,14 @@ var hasGqlCacheControlCost = function (dictHasGqlCacheControl) {

260340 }

261341 };

262342};

343+var hasGqlCacheControlDefault = function (dictHasGqlCacheControl) {

344+ var gqlCacheControl1 = gqlCacheControl(dictHasGqlCacheControl);

345+ return {

346+ gqlCacheControl: function (v) {

347+ return gqlCacheControl1(Type_Proxy["Proxy"].value);

348+ }

349+ };

350+};

263351var hasGqlCacheControlDepreca = function (dictHasGqlCacheControl) {

264352 var gqlCacheControl1 = gqlCacheControl(dictHasGqlCacheControl);

265353 return {

@@ -299,13 +387,16 @@ var hasGqlCacheControlPrivate = function (dictHasGqlCacheControl) {

299387var excluded = coerce;

300388var described = coerce;

301389var deprecated = coerce;

390+var defaulted = coerce;

302391var cost = coerce;

303392export {

304393 gqlDescription,

305394 gqlDeprecationReason,

395+ gqlDefaultValue,

306396 gqlCost,

307397 described,

308398 deprecated,

399+ defaulted,

309400 cost,

310401 maxAge,

311402 $$private as private,

@@ -317,17 +408,26 @@ export {

317408 gqlCacheControl,

318409 hasGqlDescriptionDescribe,

319410 hasGqlDescriptionNamed,

411+ hasGqlDescriptionDefaulte,

320412 hasGqlDescription,

321413 hasGqlDeprecatedDeprecate,

322414 hasGqlDeprecatedNamed,

415+ hasGqlDeprecatedDefaulted,

323416 hasGqlDeprecated,

417+ hasGqlDefaultValueDefault,

418+ hasGqlDefaultValueDescrib,

419+ hasGqlDefaultValueDepreca,

420+ hasGqlDefaultValueNamed,

421+ hasGqlDefaultValue,

324422 hasGqlCostCost,

325423 hasGqlCostDescribed,

326424 hasGqlCostDeprecated,

327425 hasGqlCostNamed,

426+ hasGqlCostDefaulted,

328427 hasGqlCost,

329428 newtypeDescribed_,

330429 newtypeDeprecated_,

430+ newtypeDefaulted_,

331431 newtypeCost_,

332432 newtypeMaxAge_,

333433 newtypePrivate_,

@@ -342,6 +442,7 @@ export {

342442 hasGqlNameCost,

343443 hasGqlNameMaxAge,

344444 hasGqlNamePrivate,

445+ hasGqlNameDefaulted,

345446 hasGqlName,

346447 hasGqlCacheControlMaxAge,

347448 hasGqlCacheControlPrivate,

@@ -349,5 +450,6 @@ export {

349450 hasGqlCacheControlDepreca,

350451 hasGqlCacheControlCost,

351452 hasGqlCacheControlNamed,

453+ hasGqlCacheControlDefault,

352454 hasGqlCacheControl

353455};

output-compile-fail/Prospero.Om/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Schema/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.Schema/index.js+118−105

@@ -24,7 +24,6 @@ import * as Record from "../Record/index.js";

2424import * as Type_Proxy from "../Type.Proxy/index.js";

2525import * as Yoga_Om from "../Yoga.Om/index.js";

2626var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();

27−var append = /* #__PURE__ */ Data_Semigroup.append(Data_Semigroup.semigroupArray);

2827var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorArray);

2928var insert = /* #__PURE__ */ Data_Map_Internal.insert(Data_Ord.ordString);

3029var map1 = /* #__PURE__ */ Data_Functor.map(Yoga_Om.functorOm);

@@ -35,6 +34,8 @@ var inj = /* #__PURE__ */ Data_Variant.inj()({

3534});

3635var throwError = /* #__PURE__ */ Control_Monad_Error_Class.throwError(Yoga_Om.monadThrowVariantExceptio);

3736var show = /* #__PURE__ */ Data_Show.show(Prospero_InputValue.showInputError);

37+var on = /* #__PURE__ */ Data_Variant.on();

38+var append = /* #__PURE__ */ Data_Semigroup.append(Data_Semigroup.semigroupArray);

3839var fromFoldable = /* #__PURE__ */ Data_Map_Internal.fromFoldable(Data_Ord.ordString)(Data_Foldable.foldableArray);

3940var PageInfoIsSymbol = {

4041 reflectSymbol: function () {

@@ -52,6 +53,10 @@ var toGqlArgsCons = function () {

5253 };

5354 };

5455};

56+var gqlVariantMembersNilRow = {

57+ variantMemberTypes: [ ],

58+ resolveVariant: Data_Variant.case_

59+};

5560var gqlSchemaStringGqlNonNull = {

5661 toGqlType: function (v) {

5762 return new Prospero_Types.NonNullType(new Prospero_Types.NamedType({

@@ -208,7 +213,7 @@ var gqlEnumResolveConstructor = function (dictIsSymbol) {

208213 if (Data_Boolean.otherwise) {

209214 return Data_Maybe.Nothing.value;

210215 };

211− throw new Error("Failed pattern match at Prospero.Schema (line 580, column 1 - line 584, column 26): " + [ s.constructor.name ]);

216+ throw new Error("Failed pattern match at Prospero.Schema (line 587, column 1 - line 591, column 26): " + [ s.constructor.name ]);

212217 }

213218 };

214219};

@@ -219,6 +224,9 @@ var gqlArgTypesMaybeGqlNullab = function () {

219224};

220225var gqlArgTypesIntGqlNonNullG = {};

221226var gqlArgTypesIDGqlNonNullGq = {};

227+var gqlArgTypesDefaulted = function () {

228+ return {};

229+};

222230var gqlArgTypesByKindScalarGq = function (dictIsSymbol) {

223231 return {};

224232};

@@ -239,8 +247,8 @@ var gqlArgTypes = function () {

239247 };

240248 };

241249};

242−var unionMemberTypes = function (dict) {

243− return dict.unionMemberTypes;

250+var variantMemberTypes = function (dict) {

251+ return dict.variantMemberTypes;

244252};

245253var toGqlTypeByKind = function (dict) {

246254 return dict.toGqlTypeByKind;

@@ -287,18 +295,21 @@ var gqlSchemaArgsCons = function (dictIsSymbol) {

287295 return function (dictFromInputValue) {

288296 return function (dictGqlSchema) {

289297 var toGqlType2 = toGqlType(dictGqlSchema);

290− return function (dictGqlSchemaArgs) {

291− var toGqlInputValues1 = toGqlInputValues(dictGqlSchemaArgs);

292− return {

293− toGqlInputValues: function (v) {

294− var iv = {

295− name: reflectSymbol(Type_Proxy["Proxy"].value),

296− description: Data_Maybe.Nothing.value,

297− type: toGqlType2(Type_Proxy["Proxy"].value),

298− defaultValue: Data_Maybe.Nothing.value

299− };

300− return Data_Array.cons(iv)(toGqlInputValues1(Type_Proxy["Proxy"].value));

301− }

298+ return function (dictHasGqlDefaultValue) {

299+ var gqlDefaultValue = Prospero_Metadata.gqlDefaultValue(dictHasGqlDefaultValue);

300+ return function (dictGqlSchemaArgs) {

301+ var toGqlInputValues1 = toGqlInputValues(dictGqlSchemaArgs);

302+ return {

303+ toGqlInputValues: function (v) {

304+ var iv = {

305+ name: reflectSymbol(Type_Proxy["Proxy"].value),

306+ description: Data_Maybe.Nothing.value,

307+ type: toGqlType2(Type_Proxy["Proxy"].value),

308+ defaultValue: gqlDefaultValue(Type_Proxy["Proxy"].value)

309+ };

310+ return Data_Array.cons(iv)(toGqlInputValues1(Type_Proxy["Proxy"].value));

311+ }

312+ };

302313 };

303314 };

304315 };

@@ -310,61 +321,43 @@ var toGqlFields = function (dict) {

310321var toFieldArgs = function (dict) {

311322 return dict.toFieldArgs;

312323};

313−var resolveUnion = function (dict) {

314− return dict.resolveUnion;

324+var resolveVariant = function (dict) {

325+ return dict.resolveVariant;

315326};

316327var gqlSchemaByKindUnionGqlNo = function (dictIsSymbol) {

317328 var reflectSymbol = Data_Symbol.reflectSymbol(dictIsSymbol);

318− return function (dictGeneric) {

319− var from = Data_Generic_Rep.from(dictGeneric);

320− return function (dictGqlUnionMembers) {

321− var unionMemberTypes1 = unionMemberTypes(dictGqlUnionMembers);

322− var resolveUnion1 = resolveUnion(dictGqlUnionMembers);

323− return {

324− toGqlTypeByKind: function (v) {

325− var extractTypeName1 = function (v1) {

326− if (v1 instanceof Prospero_Types.NonNullType && v1.value0 instanceof Prospero_Types.NamedType) {

327− return new Data_Maybe.Just(v1.value0.value0.name);

328− };

329− if (v1 instanceof Prospero_Types.NamedType) {

330− return new Data_Maybe.Just(v1.value0.name);

329+ return function () {

330+ return function () {

331+ return function (dictGqlVariantMembers) {

332+ var variantMemberTypes1 = variantMemberTypes(dictGqlVariantMembers);

333+ var resolveVariant1 = resolveVariant(dictGqlVariantMembers);

334+ return {

335+ toGqlTypeByKind: function (v) {

336+ var extractTypeName1 = function (v1) {

337+ if (v1 instanceof Prospero_Types.NonNullType && v1.value0 instanceof Prospero_Types.NamedType) {

338+ return new Data_Maybe.Just(v1.value0.value0.name);

339+ };

340+ if (v1 instanceof Prospero_Types.NamedType) {

341+ return new Data_Maybe.Just(v1.value0.name);

342+ };

343+ return Data_Maybe.Nothing.value;

331344 };

332− return Data_Maybe.Nothing.value;

333− };

334− var memberTypeNames = Data_Array.mapMaybe(extractTypeName1)(unionMemberTypes1);

335− return new Prospero_Types.NonNullType(new Prospero_Types.NamedType({

336− kind: Prospero_Types.Union.value,

337− name: reflectSymbol(Type_Proxy["Proxy"].value),

338− description: Data_Maybe.Nothing.value,

339− fields: [ ],

340− enumValues: [ ],

341− possibleTypes: memberTypeNames,

342− keys: [ ]

343− }));

344− },

345− resolveByKind: function (a) {

346− return resolveUnion1(from(a));

347− }

348− };

349− };

350− };

351−};

352−var gqlUnionMembersSum = function (dictGqlUnionMembers) {

353− var unionMemberTypes1 = unionMemberTypes(dictGqlUnionMembers);

354− var resolveUnion1 = resolveUnion(dictGqlUnionMembers);

355− return function (dictGqlUnionMembers1) {

356− var resolveUnion2 = resolveUnion(dictGqlUnionMembers1);

357− return {

358− unionMemberTypes: append(unionMemberTypes1)(unionMemberTypes(dictGqlUnionMembers1)),

359− resolveUnion: function (v) {

360− if (v instanceof Data_Generic_Rep.Inl) {

361− return resolveUnion1(v.value0);

362− };

363− if (v instanceof Data_Generic_Rep.Inr) {

364− return resolveUnion2(v.value0);

345+ var memberTypeNames = Data_Array.mapMaybe(extractTypeName1)(variantMemberTypes1);

346+ return new Prospero_Types.NonNullType(new Prospero_Types.NamedType({

347+ kind: Prospero_Types.Union.value,

348+ name: reflectSymbol(Type_Proxy["Proxy"].value),

349+ description: Data_Maybe.Nothing.value,

350+ fields: [ ],

351+ enumValues: [ ],

352+ possibleTypes: memberTypeNames,

353+ keys: [ ]

354+ }));

355+ },

356+ resolveByKind: function (a) {

357+ return resolveVariant1(unwrap(a));

358+ }

365359 };

366− throw new Error("Failed pattern match at Prospero.Schema (line 621, column 18 - line 623, column 39): " + [ v.constructor.name ]);

367− }

360+ };

368361 };

369362 };

370363};

@@ -487,9 +480,23 @@ var gqlSchemaCost = function (dictGqlSchema) {

487480 return toGqlType2(Type_Proxy["Proxy"].value);

488481 },

489482 resolve: (function () {

490− var $436 = resolve(dictGqlSchema);

491− return function ($437) {

492− return $436(unwrap($437));

483+ var $435 = resolve(dictGqlSchema);

484+ return function ($436) {

485+ return $435(unwrap($436));

486+ };

487+ })()

488+ };

489+};

490+var gqlSchemaDefaulted = function (dictGqlSchema) {

491+ var toGqlType2 = toGqlType(dictGqlSchema);

492+ return {

493+ toGqlType: function (v) {

494+ return toGqlType2(Type_Proxy["Proxy"].value);

495+ },

496+ resolve: (function () {

497+ var $437 = resolve(dictGqlSchema);

498+ return function ($438) {

499+ return $437(unwrap($438));

493500 };

494501 })()

495502 };

@@ -501,9 +508,9 @@ var gqlSchemaDeprecated = function (dictGqlSchema) {

501508 return toGqlType2(Type_Proxy["Proxy"].value);

502509 },

503510 resolve: (function () {

504− var $438 = resolve(dictGqlSchema);

505− return function ($439) {

506− return $438(unwrap($439));

511+ var $439 = resolve(dictGqlSchema);

512+ return function ($440) {

513+ return $439(unwrap($440));

507514 };

508515 })()

509516 };

@@ -515,9 +522,9 @@ var gqlSchemaDescribed = function (dictGqlSchema) {

515522 return toGqlType2(Type_Proxy["Proxy"].value);

516523 },

517524 resolve: (function () {

518− var $440 = resolve(dictGqlSchema);

519− return function ($441) {

520− return $440(unwrap($441));

525+ var $441 = resolve(dictGqlSchema);

526+ return function ($442) {

527+ return $441(unwrap($442));

521528 };

522529 })()

523530 };

@@ -529,9 +536,9 @@ var gqlSchemaExcluded = function (dictGqlSchema) {

529536 return toGqlType2(Type_Proxy["Proxy"].value);

530537 },

531538 resolve: (function () {

532− var $442 = resolve(dictGqlSchema);

533− return function ($443) {

534− return $442(unwrap($443));

539+ var $443 = resolve(dictGqlSchema);

540+ return function ($444) {

541+ return $443(unwrap($444));

535542 };

536543 })()

537544 };

@@ -578,7 +585,7 @@ var gqlSchemaFieldsCons = function (dictIsSymbol) {

578585 if (v1 instanceof Data_Maybe.Nothing) {

579586 return recordLabel;

580587 };

581− throw new Error("Failed pattern match at Prospero.Schema (line 434, column 21 - line 436, column 33): " + [ v1.constructor.name ]);

588+ throw new Error("Failed pattern match at Prospero.Schema (line 439, column 21 - line 441, column 33): " + [ v1.constructor.name ]);

582589 })();

583590 var deprecation = gqlDeprecationReason(Type_Proxy["Proxy"].value);

584591 var field = {

@@ -610,7 +617,7 @@ var gqlSchemaFieldsCons = function (dictIsSymbol) {

610617 if (v1 instanceof Data_Maybe.Nothing) {

611618 return recordLabel;

612619 };

613− throw new Error("Failed pattern match at Prospero.Schema (line 457, column 21 - line 459, column 33): " + [ v1.constructor.name ]);

620+ throw new Error("Failed pattern match at Prospero.Schema (line 462, column 21 - line 464, column 33): " + [ v1.constructor.name ]);

614621 })();

615622 var value = get(Type_Proxy["Proxy"].value)(rec);

616623 var step = resolve3(value);

@@ -639,9 +646,9 @@ var gqlSchemaMaxAge = function (dictGqlSchema) {

639646 return toGqlType2(Type_Proxy["Proxy"].value);

640647 },

641648 resolve: (function () {

642− var $444 = resolve(dictGqlSchema);

643− return function ($445) {

644− return $444(unwrap($445));

649+ var $445 = resolve(dictGqlSchema);

650+ return function ($446) {

651+ return $445(unwrap($446));

645652 };

646653 })()

647654 };

@@ -698,9 +705,9 @@ var gqlSchemaNamed = function (dictGqlSchema) {

698705 return toGqlType2(Type_Proxy["Proxy"].value);

699706 },

700707 resolve: (function () {

701− var $446 = resolve(dictGqlSchema);

702− return function ($447) {

703− return $446(unwrap($447));

708+ var $447 = resolve(dictGqlSchema);

709+ return function ($448) {

710+ return $447(unwrap($448));

704711 };

705712 })()

706713 };

@@ -724,9 +731,9 @@ var gqlSchemaPrivate = function (dictGqlSchema) {

724731 return toGqlType2(Type_Proxy["Proxy"].value);

725732 },

726733 resolve: (function () {

727− var $448 = resolve(dictGqlSchema);

728− return function ($449) {

729− return $448(unwrap($449));

734+ var $449 = resolve(dictGqlSchema);

735+ return function ($450) {

736+ return $449(unwrap($450));

730737 };

731738 })()

732739 };

@@ -746,9 +753,9 @@ var gqlSchemaRecordFunction = function () {

746753 },

747754 resolve: function (f) {

748755 var throwVariant = (function () {

749− var $450 = inj(Type_Proxy["Proxy"].value);

750− return function ($451) {

751− return $450($451);

756+ var $451 = inj(Type_Proxy["Proxy"].value);

757+ return function ($452) {

758+ return $451($452);

752759 };

753760 })();

754761 return new Prospero_Step.FunctionStep(function (inputMap) {

@@ -759,7 +766,7 @@ var gqlSchemaRecordFunction = function () {

759766 if (v instanceof Data_Either.Right) {

760767 return resolve3(f(v.value0));

761768 };

762− throw new Error("Failed pattern match at Prospero.Schema (line 219, column 5 - line 221, column 48): " + [ v.constructor.name ]);

769+ throw new Error("Failed pattern match at Prospero.Schema (line 223, column 5 - line 225, column 48): " + [ v.constructor.name ]);

763770 });

764771 }

765772 };

@@ -769,14 +776,18 @@ var gqlSchemaRecordFunction = function () {

769776 };

770777 };

771778};

772−var gqlUnionMembersConstructo = function (dictIsSymbol) {

779+var gqlVariantMembersCons = function (dictIsSymbol) {

780+ var on1 = on(dictIsSymbol);

773781 return function (dictGqlSchema) {

782+ var toGqlType2 = toGqlType(dictGqlSchema);

774783 var resolve3 = resolve(dictGqlSchema);

775− return {

776− unionMemberTypes: [ toGqlType(dictGqlSchema)(Type_Proxy["Proxy"].value) ],

777− resolveUnion: function (v) {

778− return resolve3(v);

779− }

784+ return function () {

785+ return function (dictGqlVariantMembers) {

786+ return {

787+ variantMemberTypes: Data_Array.cons(toGqlType2(Type_Proxy["Proxy"].value))(variantMemberTypes(dictGqlVariantMembers)),

788+ resolveVariant: on1(Type_Proxy["Proxy"].value)(resolve3)(resolveVariant(dictGqlVariantMembers))

789+ };

790+ };

780791 };

781792 };

782793};

@@ -1089,7 +1100,7 @@ var gqlEnumResolveSum = function (dictGqlEnumResolve) {

10891100 if (v instanceof Data_Generic_Rep.Inr) {

10901101 return enumToString2(v.value0);

10911102 };

1092− throw new Error("Failed pattern match at Prospero.Schema (line 587, column 18 - line 589, column 28): " + [ v.constructor.name ]);

1103+ throw new Error("Failed pattern match at Prospero.Schema (line 594, column 18 - line 596, column 28): " + [ v.constructor.name ]);

10931104 },

10941105 enumFromString: function (s) {

10951106 var v = enumFromString1(s);

@@ -1099,7 +1110,7 @@ var gqlEnumResolveSum = function (dictGqlEnumResolve) {

10991110 if (v instanceof Data_Maybe.Nothing) {

11001111 return map2(Data_Generic_Rep.Inr.create)(enumFromString2(s));

11011112 };

1102− throw new Error("Failed pattern match at Prospero.Schema (line 590, column 22 - line 592, column 43): " + [ v.constructor.name ]);

1113+ throw new Error("Failed pattern match at Prospero.Schema (line 597, column 22 - line 599, column 43): " + [ v.constructor.name ]);

11031114 }

11041115 };

11051116 };

@@ -1115,8 +1126,8 @@ export {

11151126 enumToString,

11161127 enumFromString,

11171128 genericFromInputValue,

1118− unionMemberTypes,

1119− resolveUnion,

1129+ variantMemberTypes,

1130+ resolveVariant,

11201131 toGqlTypeByKind,

11211132 resolveByKind,

11221133 gqlSchemaStringGqlNonNull,

@@ -1132,6 +1143,7 @@ export {

11321143 gqlSchemaConnectionGqlNon,

11331144 gqlSchemaDescribed,

11341145 gqlSchemaDeprecated,

1146+ gqlSchemaDefaulted,

11351147 gqlSchemaCost,

11361148 gqlSchemaMaxAge,

11371149 gqlSchemaNamed,

@@ -1163,6 +1175,7 @@ export {

11631175 gqlArgTypesIntGqlNonNullG,

11641176 gqlArgTypesNumberGqlNonNu,

11651177 gqlArgTypesBooleanGqlNonN,

1178+ gqlArgTypesDefaulted,

11661179 gqlArgTypesMaybeGqlNullab,

11671180 gqlArgTypesIDGqlNonNullGq,

11681181 gqlArgTypesArrayGqlNonNul,

@@ -1176,6 +1189,6 @@ export {

11761189 gqlEnumValuesSum,

11771190 gqlEnumResolveConstructor,

11781191 gqlEnumResolveSum,

1179− gqlUnionMembersConstructo,

1180− gqlUnionMembersSum

1192+ gqlVariantMembersNilRow,

1193+ gqlVariantMembersCons

11811194};

output-compile-fail/Prospero.VariantHelper/externs.cbornew file

Binary file not shown.

output-compile-fail/Prospero.VariantHelper/index.jsnew file+61

@@ -0,0 +1,61 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Newtype from "../Data.Newtype/index.js";

3+import * as Data_Variant from "../Data.Variant/index.js";

4+import * as Type_Proxy from "../Type.Proxy/index.js";

5+var wrap = /* #__PURE__ */ Data_Newtype.wrap();

6+var inj = /* #__PURE__ */ Data_Variant.inj();

7+var on1 = /* #__PURE__ */ Data_Variant.on();

8+var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();

9+var match1 = /* #__PURE__ */ Data_Variant.match()()();

10+var tag = function () {

11+ return function () {

12+ return function (dictIsSymbol) {

13+ var inj1 = inj(dictIsSymbol);

14+ return function (a) {

15+ return wrap(inj1(Type_Proxy["Proxy"].value)(a));

16+ };

17+ };

18+ };

19+};

20+var on = function () {

21+ return function () {

22+ return function () {

23+ return function (dictIsSymbol) {

24+ var on2 = on1(dictIsSymbol);

25+ return function (f) {

26+ return function (g) {

27+ return function (v) {

28+ return on2(Type_Proxy["Proxy"].value)(f)(function ($12) {

29+ return g(wrap($12));

30+ })(unwrap(v));

31+ };

32+ };

33+ };

34+ };

35+ };

36+ };

37+};

38+var match = function () {

39+ return function () {

40+ return function () {

41+ return function () {

42+ return function (handlers) {

43+ return function (v) {

44+ return match1(handlers)(unwrap(v));

45+ };

46+ };

47+ };

48+ };

49+ };

50+};

51+var case_ = function () {

52+ return function (v) {

53+ return Data_Variant.case_(unwrap(v));

54+ };

55+};

56+export {

57+ match,

58+ on,

59+ case_,

60+ tag

61+};

output-compile-fail/Prospero.WebSocket/externs.cbor

Binary file not shown.

output-compile-fail/Prospero.WebSocket/foreign.js+4−24

@@ -1,27 +1,7 @@

1−import { WebSocketServer } from "ws";

2−

3−export const createWsServerImpl = (options) => () => {

4− return new WebSocketServer(options);

5−};

6−

7−export const onConnectionImpl = (wss) => (handler) => () => {

8− wss.on("connection", (ws) => {

9− handler(ws)();

10− });

11−};

12−

13−export const onMessageImpl = (ws) => (handler) => () => {

14− ws.on("message", (data) => {

15− handler(data.toString())();

16− });

17−};

18−

19−export const onCloseImpl = (ws) => (handler) => () => {

20− ws.on("close", () => {

21− handler();

22− });

23−};

24−

251export const sendImpl = (ws) => (msg) => () => {

262 ws.send(msg);

273};

4+

5+export const closeImpl = (ws) => () => {

6+ ws.close();

7+};

output-compile-fail/Prospero.WebSocket/index.js+3−11

@@ -1,16 +1,8 @@

11// Generated by purs version 0.15.15

22import * as $foreign from "./foreign.js";

33var send = $foreign.sendImpl;

4−var onMessage = $foreign.onMessageImpl;

5−var onConnection = $foreign.onConnectionImpl;

6−var onClose = $foreign.onCloseImpl;

7−var createWsServer = /* #__PURE__ */ $foreign.createWsServerImpl({

8− noServer: true

9−});

4+var close = $foreign.closeImpl;

105export {

11− createWsServer,

12− onConnection,

13− onMessage,

14− onClose,

15− send

6+ send,

7+ close

168};

output-compile-fail/Prospero/externs.cbor

Binary file not shown.

output-compile-fail/Prospero/index.js+5−4

@@ -1,4 +1,5 @@

11// Generated by purs version 0.15.15

2+import * as Prospero_Bun from "../Prospero.Bun/index.js";

23import * as Prospero_CacheControl from "../Prospero.CacheControl/index.js";

34import * as Prospero_Client from "../Prospero.Client/index.js";

45import * as Prospero_DataLoader from "../Prospero.DataLoader/index.js";

@@ -27,6 +28,9 @@ import * as Prospero_WebSocket from "../Prospero.WebSocket/index.js";

2728import * as Prospero_Wrapper from "../Prospero.Wrapper/index.js";

2829import * as Yoga_Om from "../Yoga.Om/index.js";

2930

31+export {

32+ serve

33+} from "../Prospero.Bun/index.js";

3034export {

3135 cacheControl,

3236 cacheControlFor

@@ -187,10 +191,7 @@ export {

187191 registerMultipart

188192} from "../Prospero.Upload/index.js";

189193export {

190− createWsServer,

191− onClose,

192− onConnection,

193− onMessage,

194+ close,

194195 send

195196} from "../Prospero.WebSocket/index.js";

196197export {

output-compile-fail/PureScript.CST.Errors/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Errors/index.jsnew file+302

@@ -0,0 +1,302 @@

1+// Generated by purs version 0.15.15

2+import * as PureScript_CST_Print from "../PureScript.CST.Print/index.js";

3+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

4+var UnexpectedEof = /* #__PURE__ */ (function () {

5+ function UnexpectedEof() {

6+

7+ };

8+ UnexpectedEof.value = new UnexpectedEof();

9+ return UnexpectedEof;

10+})();

11+var ExpectedEof = /* #__PURE__ */ (function () {

12+ function ExpectedEof(value0) {

13+ this.value0 = value0;

14+ };

15+ ExpectedEof.create = function (value0) {

16+ return new ExpectedEof(value0);

17+ };

18+ return ExpectedEof;

19+})();

20+var UnexpectedToken = /* #__PURE__ */ (function () {

21+ function UnexpectedToken(value0) {

22+ this.value0 = value0;

23+ };

24+ UnexpectedToken.create = function (value0) {

25+ return new UnexpectedToken(value0);

26+ };

27+ return UnexpectedToken;

28+})();

29+var ExpectedToken = /* #__PURE__ */ (function () {

30+ function ExpectedToken(value0, value1) {

31+ this.value0 = value0;

32+ this.value1 = value1;

33+ };

34+ ExpectedToken.create = function (value0) {

35+ return function (value1) {

36+ return new ExpectedToken(value0, value1);

37+ };

38+ };

39+ return ExpectedToken;

40+})();

41+var ExpectedClass = /* #__PURE__ */ (function () {

42+ function ExpectedClass(value0, value1) {

43+ this.value0 = value0;

44+ this.value1 = value1;

45+ };

46+ ExpectedClass.create = function (value0) {

47+ return function (value1) {

48+ return new ExpectedClass(value0, value1);

49+ };

50+ };

51+ return ExpectedClass;

52+})();

53+var LexExpected = /* #__PURE__ */ (function () {

54+ function LexExpected(value0, value1) {

55+ this.value0 = value0;

56+ this.value1 = value1;

57+ };

58+ LexExpected.create = function (value0) {

59+ return function (value1) {

60+ return new LexExpected(value0, value1);

61+ };

62+ };

63+ return LexExpected;

64+})();

65+var LexInvalidCharEscape = /* #__PURE__ */ (function () {

66+ function LexInvalidCharEscape(value0) {

67+ this.value0 = value0;

68+ };

69+ LexInvalidCharEscape.create = function (value0) {

70+ return new LexInvalidCharEscape(value0);

71+ };

72+ return LexInvalidCharEscape;

73+})();

74+var LexCharEscapeOutOfRange = /* #__PURE__ */ (function () {

75+ function LexCharEscapeOutOfRange(value0) {

76+ this.value0 = value0;

77+ };

78+ LexCharEscapeOutOfRange.create = function (value0) {

79+ return new LexCharEscapeOutOfRange(value0);

80+ };

81+ return LexCharEscapeOutOfRange;

82+})();

83+var LexHexOutOfRange = /* #__PURE__ */ (function () {

84+ function LexHexOutOfRange(value0) {

85+ this.value0 = value0;

86+ };

87+ LexHexOutOfRange.create = function (value0) {

88+ return new LexHexOutOfRange(value0);

89+ };

90+ return LexHexOutOfRange;

91+})();

92+var LexIntOutOfRange = /* #__PURE__ */ (function () {

93+ function LexIntOutOfRange(value0) {

94+ this.value0 = value0;

95+ };

96+ LexIntOutOfRange.create = function (value0) {

97+ return new LexIntOutOfRange(value0);

98+ };

99+ return LexIntOutOfRange;

100+})();

101+var LexNumberOutOfRange = /* #__PURE__ */ (function () {

102+ function LexNumberOutOfRange(value0) {

103+ this.value0 = value0;

104+ };

105+ LexNumberOutOfRange.create = function (value0) {

106+ return new LexNumberOutOfRange(value0);

107+ };

108+ return LexNumberOutOfRange;

109+})();

110+var RecoveredError = function (x) {

111+ return x;

112+};

113+var printTokenError = function (v) {

114+ if (v instanceof PureScript_CST_Types.TokLeftParen) {

115+ return "'('";

116+ };

117+ if (v instanceof PureScript_CST_Types.TokRightParen) {

118+ return "')'";

119+ };

120+ if (v instanceof PureScript_CST_Types.TokLeftBrace) {

121+ return "'{'";

122+ };

123+ if (v instanceof PureScript_CST_Types.TokRightBrace) {

124+ return "'}'";

125+ };

126+ if (v instanceof PureScript_CST_Types.TokLeftSquare) {

127+ return "'['";

128+ };

129+ if (v instanceof PureScript_CST_Types.TokRightSquare) {

130+ return "']'";

131+ };

132+ if (v instanceof PureScript_CST_Types.TokLeftArrow) {

133+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

134+ return "'<-'";

135+ };

136+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

137+ return "'\u2190'";

138+ };

139+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 72, column 5 - line 74, column 23): " + [ v.value0.constructor.name ]);

140+ };

141+ if (v instanceof PureScript_CST_Types.TokRightArrow) {

142+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

143+ return "'->'";

144+ };

145+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

146+ return "'\u2192'";

147+ };

148+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 76, column 5 - line 78, column 23): " + [ v.value0.constructor.name ]);

149+ };

150+ if (v instanceof PureScript_CST_Types.TokRightFatArrow) {

151+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

152+ return "'=>'";

153+ };

154+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

155+ return "'\u21d2'";

156+ };

157+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 80, column 5 - line 82, column 23): " + [ v.value0.constructor.name ]);

158+ };

159+ if (v instanceof PureScript_CST_Types.TokDoubleColon) {

160+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

161+ return "'::'";

162+ };

163+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

164+ return "'\u2237'";

165+ };

166+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 84, column 5 - line 86, column 23): " + [ v.value0.constructor.name ]);

167+ };

168+ if (v instanceof PureScript_CST_Types.TokForall) {

169+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

170+ return "forall";

171+ };

172+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

173+ return "'\u2200'";

174+ };

175+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 88, column 5 - line 90, column 23): " + [ v.value0.constructor.name ]);

176+ };

177+ if (v instanceof PureScript_CST_Types.TokEquals) {

178+ return "'='";

179+ };

180+ if (v instanceof PureScript_CST_Types.TokPipe) {

181+ return "'|'";

182+ };

183+ if (v instanceof PureScript_CST_Types.TokTick) {

184+ return "`";

185+ };

186+ if (v instanceof PureScript_CST_Types.TokDot) {

187+ return ".";

188+ };

189+ if (v instanceof PureScript_CST_Types.TokComma) {

190+ return "','";

191+ };

192+ if (v instanceof PureScript_CST_Types.TokUnderscore) {

193+ return "'_'";

194+ };

195+ if (v instanceof PureScript_CST_Types.TokBackslash) {

196+ return "'\\'";

197+ };

198+ if (v instanceof PureScript_CST_Types.TokAt) {

199+ return "'@'";

200+ };

201+ if (v instanceof PureScript_CST_Types.TokLowerName) {

202+ return "identifier " + PureScript_CST_Print.printQualified(v.value0)(v.value1);

203+ };

204+ if (v instanceof PureScript_CST_Types.TokUpperName) {

205+ return "proper identifier " + PureScript_CST_Print.printQualified(v.value0)(v.value1);

206+ };

207+ if (v instanceof PureScript_CST_Types.TokOperator) {

208+ return "operator " + PureScript_CST_Print.printQualified(v.value0)(v.value1);

209+ };

210+ if (v instanceof PureScript_CST_Types.TokSymbolName) {

211+ return "symbol " + PureScript_CST_Print.printQualified(v.value0)(v.value1);

212+ };

213+ if (v instanceof PureScript_CST_Types.TokSymbolArrow) {

214+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

215+ return "(->)";

216+ };

217+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

218+ return "(\u2192)";

219+ };

220+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 116, column 5 - line 118, column 23): " + [ v.value0.constructor.name ]);

221+ };

222+ if (v instanceof PureScript_CST_Types.TokHole) {

223+ return "hole ?" + v.value0;

224+ };

225+ if (v instanceof PureScript_CST_Types.TokChar) {

226+ return "char literal '" + (v.value0 + "'");

227+ };

228+ if (v instanceof PureScript_CST_Types.TokString) {

229+ return "string literal";

230+ };

231+ if (v instanceof PureScript_CST_Types.TokRawString) {

232+ return "raw string literal";

233+ };

234+ if (v instanceof PureScript_CST_Types.TokInt) {

235+ return "int literal " + v.value0;

236+ };

237+ if (v instanceof PureScript_CST_Types.TokNumber) {

238+ return "number literal " + v.value0;

239+ };

240+ if (v instanceof PureScript_CST_Types.TokLayoutStart) {

241+ return "start of indented block";

242+ };

243+ if (v instanceof PureScript_CST_Types.TokLayoutSep) {

244+ return "new indented block item";

245+ };

246+ if (v instanceof PureScript_CST_Types.TokLayoutEnd) {

247+ return "end of indented block";

248+ };

249+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 58, column 19 - line 136, column 28): " + [ v.constructor.name ]);

250+};

251+var printParseError = function (v) {

252+ if (v instanceof UnexpectedEof) {

253+ return "Unexpected end of file";

254+ };

255+ if (v instanceof ExpectedEof) {

256+ return "Expected end of file, saw " + printTokenError(v.value0);

257+ };

258+ if (v instanceof UnexpectedToken) {

259+ return "Unexpected " + printTokenError(v.value0);

260+ };

261+ if (v instanceof ExpectedToken) {

262+ return "Expected " + (printTokenError(v.value0) + (", saw " + printTokenError(v.value1)));

263+ };

264+ if (v instanceof ExpectedClass) {

265+ return "Expected " + (v.value0 + (", saw " + printTokenError(v.value1)));

266+ };

267+ if (v instanceof LexExpected) {

268+ return "Expected " + (v.value0 + (", saw " + v.value1));

269+ };

270+ if (v instanceof LexInvalidCharEscape) {

271+ return "Invalid character escape \\" + v.value0;

272+ };

273+ if (v instanceof LexCharEscapeOutOfRange) {

274+ return "Character escape out of range \\" + v.value0;

275+ };

276+ if (v instanceof LexHexOutOfRange) {

277+ return "Hex integer out of range 0x" + v.value0;

278+ };

279+ if (v instanceof LexIntOutOfRange) {

280+ return "Int out of range " + v.value0;

281+ };

282+ if (v instanceof LexNumberOutOfRange) {

283+ return "Number out of range " + v.value0;

284+ };

285+ throw new Error("Failed pattern match at PureScript.CST.Errors (line 33, column 19 - line 55, column 34): " + [ v.constructor.name ]);

286+};

287+export {

288+ RecoveredError,

289+ UnexpectedEof,

290+ ExpectedEof,

291+ UnexpectedToken,

292+ ExpectedToken,

293+ ExpectedClass,

294+ LexExpected,

295+ LexInvalidCharEscape,

296+ LexCharEscapeOutOfRange,

297+ LexHexOutOfRange,

298+ LexIntOutOfRange,

299+ LexNumberOutOfRange,

300+ printParseError,

301+ printTokenError

302+};

output-compile-fail/PureScript.CST.Layout/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Layout/index.jsnew file+901

@@ -0,0 +1,901 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array from "../Data.Array/index.js";

3+import * as Data_Boolean from "../Data.Boolean/index.js";

4+import * as Data_Eq from "../Data.Eq/index.js";

5+import * as Data_Foldable from "../Data.Foldable/index.js";

6+import * as Data_Function from "../Data.Function/index.js";

7+import * as Data_List_Types from "../Data.List.Types/index.js";

8+import * as Data_Maybe from "../Data.Maybe/index.js";

9+import * as Data_Ordering from "../Data.Ordering/index.js";

10+import * as Data_Tuple from "../Data.Tuple/index.js";

11+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

12+var find = /* #__PURE__ */ Data_Foldable.find(Data_List_Types.foldableList);

13+var LytRoot = /* #__PURE__ */ (function () {

14+ function LytRoot() {

15+

16+ };

17+ LytRoot.value = new LytRoot();

18+ return LytRoot;

19+})();

20+var LytTopDecl = /* #__PURE__ */ (function () {

21+ function LytTopDecl() {

22+

23+ };

24+ LytTopDecl.value = new LytTopDecl();

25+ return LytTopDecl;

26+})();

27+var LytTopDeclHead = /* #__PURE__ */ (function () {

28+ function LytTopDeclHead() {

29+

30+ };

31+ LytTopDeclHead.value = new LytTopDeclHead();

32+ return LytTopDeclHead;

33+})();

34+var LytDeclGuard = /* #__PURE__ */ (function () {

35+ function LytDeclGuard() {

36+

37+ };

38+ LytDeclGuard.value = new LytDeclGuard();

39+ return LytDeclGuard;

40+})();

41+var LytCase = /* #__PURE__ */ (function () {

42+ function LytCase() {

43+

44+ };

45+ LytCase.value = new LytCase();

46+ return LytCase;

47+})();

48+var LytCaseBinders = /* #__PURE__ */ (function () {

49+ function LytCaseBinders() {

50+

51+ };

52+ LytCaseBinders.value = new LytCaseBinders();

53+ return LytCaseBinders;

54+})();

55+var LytCaseGuard = /* #__PURE__ */ (function () {

56+ function LytCaseGuard() {

57+

58+ };

59+ LytCaseGuard.value = new LytCaseGuard();

60+ return LytCaseGuard;

61+})();

62+var LytLambdaBinders = /* #__PURE__ */ (function () {

63+ function LytLambdaBinders() {

64+

65+ };

66+ LytLambdaBinders.value = new LytLambdaBinders();

67+ return LytLambdaBinders;

68+})();

69+var LytParen = /* #__PURE__ */ (function () {

70+ function LytParen() {

71+

72+ };

73+ LytParen.value = new LytParen();

74+ return LytParen;

75+})();

76+var LytBrace = /* #__PURE__ */ (function () {

77+ function LytBrace() {

78+

79+ };

80+ LytBrace.value = new LytBrace();

81+ return LytBrace;

82+})();

83+var LytSquare = /* #__PURE__ */ (function () {

84+ function LytSquare() {

85+

86+ };

87+ LytSquare.value = new LytSquare();

88+ return LytSquare;

89+})();

90+var LytIf = /* #__PURE__ */ (function () {

91+ function LytIf() {

92+

93+ };

94+ LytIf.value = new LytIf();

95+ return LytIf;

96+})();

97+var LytThen = /* #__PURE__ */ (function () {

98+ function LytThen() {

99+

100+ };

101+ LytThen.value = new LytThen();

102+ return LytThen;

103+})();

104+var LytProperty = /* #__PURE__ */ (function () {

105+ function LytProperty() {

106+

107+ };

108+ LytProperty.value = new LytProperty();

109+ return LytProperty;

110+})();

111+var LytForall = /* #__PURE__ */ (function () {

112+ function LytForall() {

113+

114+ };

115+ LytForall.value = new LytForall();

116+ return LytForall;

117+})();

118+var LytTick = /* #__PURE__ */ (function () {

119+ function LytTick() {

120+

121+ };

122+ LytTick.value = new LytTick();

123+ return LytTick;

124+})();

125+var LytLet = /* #__PURE__ */ (function () {

126+ function LytLet() {

127+

128+ };

129+ LytLet.value = new LytLet();

130+ return LytLet;

131+})();

132+var LytLetStmt = /* #__PURE__ */ (function () {

133+ function LytLetStmt() {

134+

135+ };

136+ LytLetStmt.value = new LytLetStmt();

137+ return LytLetStmt;

138+})();

139+var LytWhere = /* #__PURE__ */ (function () {

140+ function LytWhere() {

141+

142+ };

143+ LytWhere.value = new LytWhere();

144+ return LytWhere;

145+})();

146+var LytOf = /* #__PURE__ */ (function () {

147+ function LytOf() {

148+

149+ };

150+ LytOf.value = new LytOf();

151+ return LytOf;

152+})();

153+var LytDo = /* #__PURE__ */ (function () {

154+ function LytDo() {

155+

156+ };

157+ LytDo.value = new LytDo();

158+ return LytDo;

159+})();

160+var LytAdo = /* #__PURE__ */ (function () {

161+ function LytAdo() {

162+

163+ };

164+ LytAdo.value = new LytAdo();

165+ return LytAdo;

166+})();

167+var lytToken = function (pos) {

168+ return function (value) {

169+ return {

170+ range: {

171+ start: pos,

172+ end: pos

173+ },

174+ leadingComments: [ ],

175+ trailingComments: [ ],

176+ value: value

177+ };

178+ };

179+};

180+var isTopDecl = function (tokPos) {

181+ return function (v) {

182+ if (v instanceof Data_List_Types.Cons && (v.value0.value1 instanceof LytWhere && (v.value1 instanceof Data_List_Types.Cons && (v.value1.value0.value1 instanceof LytRoot && (v.value1.value1 instanceof Data_List_Types.Nil && tokPos.column === v.value0.value0.column))))) {

183+ return true;

184+ };

185+ return false;

186+ };

187+};

188+var isIndented = function (v) {

189+ if (v instanceof LytLet) {

190+ return true;

191+ };

192+ if (v instanceof LytLetStmt) {

193+ return true;

194+ };

195+ if (v instanceof LytWhere) {

196+ return true;

197+ };

198+ if (v instanceof LytOf) {

199+ return true;

200+ };

201+ if (v instanceof LytDo) {

202+ return true;

203+ };

204+ if (v instanceof LytAdo) {

205+ return true;

206+ };

207+ return false;

208+};

209+var eqLayoutDelim = {

210+ eq: function (x) {

211+ return function (y) {

212+ if (x instanceof LytRoot && y instanceof LytRoot) {

213+ return true;

214+ };

215+ if (x instanceof LytTopDecl && y instanceof LytTopDecl) {

216+ return true;

217+ };

218+ if (x instanceof LytTopDeclHead && y instanceof LytTopDeclHead) {

219+ return true;

220+ };

221+ if (x instanceof LytDeclGuard && y instanceof LytDeclGuard) {

222+ return true;

223+ };

224+ if (x instanceof LytCase && y instanceof LytCase) {

225+ return true;

226+ };

227+ if (x instanceof LytCaseBinders && y instanceof LytCaseBinders) {

228+ return true;

229+ };

230+ if (x instanceof LytCaseGuard && y instanceof LytCaseGuard) {

231+ return true;

232+ };

233+ if (x instanceof LytLambdaBinders && y instanceof LytLambdaBinders) {

234+ return true;

235+ };

236+ if (x instanceof LytParen && y instanceof LytParen) {

237+ return true;

238+ };

239+ if (x instanceof LytBrace && y instanceof LytBrace) {

240+ return true;

241+ };

242+ if (x instanceof LytSquare && y instanceof LytSquare) {

243+ return true;

244+ };

245+ if (x instanceof LytIf && y instanceof LytIf) {

246+ return true;

247+ };

248+ if (x instanceof LytThen && y instanceof LytThen) {

249+ return true;

250+ };

251+ if (x instanceof LytProperty && y instanceof LytProperty) {

252+ return true;

253+ };

254+ if (x instanceof LytForall && y instanceof LytForall) {

255+ return true;

256+ };

257+ if (x instanceof LytTick && y instanceof LytTick) {

258+ return true;

259+ };

260+ if (x instanceof LytLet && y instanceof LytLet) {

261+ return true;

262+ };

263+ if (x instanceof LytLetStmt && y instanceof LytLetStmt) {

264+ return true;

265+ };

266+ if (x instanceof LytWhere && y instanceof LytWhere) {

267+ return true;

268+ };

269+ if (x instanceof LytOf && y instanceof LytOf) {

270+ return true;

271+ };

272+ if (x instanceof LytDo && y instanceof LytDo) {

273+ return true;

274+ };

275+ if (x instanceof LytAdo && y instanceof LytAdo) {

276+ return true;

277+ };

278+ return false;

279+ };

280+ }

281+};

282+var eq1 = /* #__PURE__ */ Data_Eq.eq(eqLayoutDelim);

283+var insertLayout = function (v) {

284+ return function (nextPos) {

285+ return function (stack) {

286+ var sepP = function (lytPos) {

287+ return v.range.start.column === lytPos.column && v.range.start.line !== lytPos.line;

288+ };

289+ var pushStack = function (lytPos) {

290+ return function (lyt) {

291+ return function (v1) {

292+ return new Data_Tuple.Tuple(new Data_List_Types.Cons(new Data_Tuple.Tuple(lytPos, lyt), v1.value0), v1.value1);

293+ };

294+ };

295+ };

296+ var popStack = function (v1) {

297+ return function (v2) {

298+ if (v2.value0 instanceof Data_List_Types.Cons && v1(v2.value0.value0.value1)) {

299+ return new Data_Tuple.Tuple(v2.value0.value1, v2.value1);

300+ };

301+ return v2;

302+ };

303+ };

304+ var offsideP = function (lytPos) {

305+ return function (lyt) {

306+ return isIndented(lyt) && v.range.start.column < lytPos.column;

307+ };

308+ };

309+ var offsideEndP = function (lytPos) {

310+ return function (lyt) {

311+ return isIndented(lyt) && v.range.start.column <= lytPos.column;

312+ };

313+ };

314+ var insertToken = function (token) {

315+ return function (v1) {

316+ return new Data_Tuple.Tuple(v1.value0, Data_Array.snoc(v1.value1)(new Data_Tuple.Tuple(token, v1.value0)));

317+ };

318+ };

319+ var insertStart = function (lyt) {

320+ return function (v1) {

321+ var v2 = find(function ($307) {

322+ return isIndented(Data_Tuple.snd($307));

323+ })(v1.value0);

324+ if (v2 instanceof Data_Maybe.Just && nextPos.column <= v2.value0.value0.column) {

325+ return v1;

326+ };

327+ return insertToken(lytToken(nextPos)(new PureScript_CST_Types.TokLayoutStart(nextPos.column)))(pushStack(nextPos)(lyt)(v1));

328+ };

329+ };

330+ var insertEnd = function (indent) {

331+ return insertToken(lytToken(v.range.start)(new PureScript_CST_Types.TokLayoutEnd(indent)));

332+ };

333+ var indentedP = Data_Function["const"](isIndented);

334+ var indentSepP = function (lytPos) {

335+ return function (lyt) {

336+ return isIndented(lyt) && sepP(lytPos);

337+ };

338+ };

339+ var insertSep = function (v1) {

340+ var sepTok = lytToken(v.range.start)(new PureScript_CST_Types.TokLayoutSep(v.range.start.column));

341+ if (v1.value0 instanceof Data_List_Types.Cons && (v1.value0.value0.value1 instanceof LytTopDecl && sepP(v1.value0.value0.value0))) {

342+ return insertToken(sepTok)(new Data_Tuple.Tuple(v1.value0.value1, v1.value1));

343+ };

344+ if (v1.value0 instanceof Data_List_Types.Cons && (v1.value0.value0.value1 instanceof LytTopDeclHead && sepP(v1.value0.value0.value0))) {

345+ return insertToken(sepTok)(new Data_Tuple.Tuple(v1.value0.value1, v1.value1));

346+ };

347+ if (v1.value0 instanceof Data_List_Types.Cons && indentSepP(v1.value0.value0.value0)(v1.value0.value0.value1)) {

348+ if (v1.value0.value0.value1 instanceof LytOf) {

349+ return pushStack(v.range.start)(LytCaseBinders.value)(insertToken(sepTok)(v1));

350+ };

351+ return insertToken(sepTok)(v1);

352+ };

353+ return v1;

354+ };

355+ var collapse = function (p) {

356+ var go = function ($copy_v1) {

357+ return function ($copy_v2) {

358+ var $tco_var_v1 = $copy_v1;

359+ var $tco_done = false;

360+ var $tco_result;

361+ function $tco_loop(v1, v2) {

362+ if (v1 instanceof Data_List_Types.Cons && p(v1.value0.value0)(v1.value0.value1)) {

363+ $tco_var_v1 = v1.value1;

364+ $copy_v2 = (function () {

365+ var $120 = isIndented(v1.value0.value1);

366+ if ($120) {

367+ return Data_Array.snoc(v2)(new Data_Tuple.Tuple(lytToken(v.range.start)(new PureScript_CST_Types.TokLayoutEnd(v1.value0.value0.column)), v1.value1));

368+ };

369+ return v2;

370+ })();

371+ return;

372+ };

373+ $tco_done = true;

374+ return new Data_Tuple.Tuple(v1, v2);

375+ };

376+ while (!$tco_done) {

377+ $tco_result = $tco_loop($tco_var_v1, $copy_v2);

378+ };

379+ return $tco_result;

380+ };

381+ };

382+ return Data_Tuple.uncurry(go);

383+ };

384+ var insertDefault = function (state) {

385+ return insertToken(v)(insertSep(collapse(offsideP)(state)));

386+ };

387+ var insertKwProperty = function (k) {

388+ return function (state) {

389+ var v1 = insertDefault(state);

390+ if (v1.value0 instanceof Data_List_Types.Cons && v1.value0.value0.value1 instanceof LytProperty) {

391+ return new Data_Tuple.Tuple(v1.value0.value1, v1.value1);

392+ };

393+ return k(v1);

394+ };

395+ };

396+ var insert = function (v1) {

397+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "data")) {

398+ var v2 = insertDefault(v1);

399+ if (isTopDecl(v.range.start)(v2.value0)) {

400+ return pushStack(v.range.start)(LytTopDecl.value)(v2);

401+ };

402+ return popStack(function (v3) {

403+ return eq1(v3)(LytProperty.value);

404+ })(v2);

405+ };

406+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "class")) {

407+ var v2 = insertDefault(v1);

408+ if (isTopDecl(v.range.start)(v2.value0)) {

409+ return pushStack(v.range.start)(LytTopDeclHead.value)(v2);

410+ };

411+ return popStack(function (v3) {

412+ return eq1(v3)(LytProperty.value);

413+ })(v2);

414+ };

415+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "where")) {

416+ var whereP = function (v2) {

417+ return function (v3) {

418+ if (v3 instanceof LytDo) {

419+ return true;

420+ };

421+ return offsideEndP(v2)(v3);

422+ };

423+ };

424+ if (v1.value0 instanceof Data_List_Types.Cons && v1.value0.value0.value1 instanceof LytTopDeclHead) {

425+ return insertStart(LytWhere.value)(insertToken(v)(new Data_Tuple.Tuple(v1.value0.value1, v1.value1)));

426+ };

427+ if (v1.value0 instanceof Data_List_Types.Cons && v1.value0.value0.value1 instanceof LytProperty) {

428+ return insertToken(v)(new Data_Tuple.Tuple(v1.value0.value1, v1.value1));

429+ };

430+ return insertStart(LytWhere.value)(insertToken(v)(collapse(whereP)(v1)));

431+ };

432+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "in")) {

433+ var inP = function (v2) {

434+ return function (v3) {

435+ if (v3 instanceof LytLet) {

436+ return false;

437+ };

438+ if (v3 instanceof LytAdo) {

439+ return false;

440+ };

441+ return isIndented(v3);

442+ };

443+ };

444+ var v2 = collapse(inP)(v1);

445+ if (v2.value0 instanceof Data_List_Types.Cons && (v2.value0.value0.value1 instanceof LytLetStmt && (v2.value0.value1 instanceof Data_List_Types.Cons && v2.value0.value1.value0.value1 instanceof LytAdo))) {

446+ return insertToken(v)(insertEnd(v2.value0.value1.value0.value0.column)(insertEnd(v2.value0.value0.value0.column)(new Data_Tuple.Tuple(v2.value0.value1.value1, v2.value1))));

447+ };

448+ if (v2.value0 instanceof Data_List_Types.Cons && isIndented(v2.value0.value0.value1)) {

449+ return insertToken(v)(insertEnd(v2.value0.value0.value0.column)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1)));

450+ };

451+ return popStack(function (v3) {

452+ return eq1(v3)(LytProperty.value);

453+ })(insertDefault(v1));

454+ };

455+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "let")) {

456+ var next = function (v2) {

457+ if (v2.value0 instanceof Data_List_Types.Cons && (v2.value0.value0.value1 instanceof LytDo && v2.value0.value0.value0.column === v.range.start.column)) {

458+ return insertStart(LytLetStmt.value)(v2);

459+ };

460+ if (v2.value0 instanceof Data_List_Types.Cons && (v2.value0.value0.value1 instanceof LytAdo && v2.value0.value0.value0.column === v.range.start.column)) {

461+ return insertStart(LytLetStmt.value)(v2);

462+ };

463+ return insertStart(LytLet.value)(v2);

464+ };

465+ return insertKwProperty(next)(v1);

466+ };

467+ if (v.value instanceof PureScript_CST_Types.TokLowerName && v.value.value1 === "do") {

468+ return insertKwProperty(insertStart(LytDo.value))(v1);

469+ };

470+ if (v.value instanceof PureScript_CST_Types.TokLowerName && v.value.value1 === "ado") {

471+ return insertKwProperty(insertStart(LytAdo.value))(v1);

472+ };

473+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "case")) {

474+ return insertKwProperty(pushStack(v.range.start)(LytCase.value))(v1);

475+ };

476+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "of")) {

477+ var v2 = collapse(indentedP)(v1);

478+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytCase) {

479+ return pushStack(nextPos)(LytCaseBinders.value)(insertStart(LytOf.value)(insertToken(v)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1))));

480+ };

481+ return popStack(function (v3) {

482+ return eq1(v3)(LytProperty.value);

483+ })(insertDefault(v2));

484+ };

485+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "if")) {

486+ return insertKwProperty(pushStack(v.range.start)(LytIf.value))(v1);

487+ };

488+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "then")) {

489+ var v2 = collapse(indentedP)(v1);

490+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytIf) {

491+ return pushStack(v.range.start)(LytThen.value)(insertToken(v)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1)));

492+ };

493+ return popStack(function (v3) {

494+ return eq1(v3)(LytProperty.value);

495+ })(insertDefault(v1));

496+ };

497+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "else")) {

498+ var v2 = collapse(indentedP)(v1);

499+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytThen) {

500+ return insertToken(v)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1));

501+ };

502+ var v3 = collapse(offsideP)(v1);

503+ if (isTopDecl(v.range.start)(v3.value0)) {

504+ return insertToken(v)(v3);

505+ };

506+ return popStack(function (v4) {

507+ return eq1(v4)(LytProperty.value);

508+ })(insertToken(v)(insertSep(v3)));

509+ };

510+ if (v.value instanceof PureScript_CST_Types.TokForall) {

511+ return insertKwProperty(pushStack(v.range.start)(LytForall.value))(v1);

512+ };

513+ if (v.value instanceof PureScript_CST_Types.TokBackslash) {

514+ return pushStack(v.range.start)(LytLambdaBinders.value)(insertDefault(v1));

515+ };

516+ if (v.value instanceof PureScript_CST_Types.TokRightArrow) {

517+ var guardP = function (v2) {

518+ if (v2 instanceof LytCaseBinders) {

519+ return true;

520+ };

521+ if (v2 instanceof LytCaseGuard) {

522+ return true;

523+ };

524+ if (v2 instanceof LytLambdaBinders) {

525+ return true;

526+ };

527+ return false;

528+ };

529+ var arrowP = function (v2) {

530+ return function (v3) {

531+ if (v3 instanceof LytDo) {

532+ return true;

533+ };

534+ if (v3 instanceof LytOf) {

535+ return false;

536+ };

537+ return offsideEndP(v2)(v3);

538+ };

539+ };

540+ return insertToken(v)(popStack(guardP)(collapse(arrowP)(v1)));

541+ };

542+ if (v.value instanceof PureScript_CST_Types.TokEquals) {

543+ var equalsP = function (v2) {

544+ return function (v3) {

545+ if (v3 instanceof LytWhere) {

546+ return true;

547+ };

548+ if (v3 instanceof LytLet) {

549+ return true;

550+ };

551+ if (v3 instanceof LytLetStmt) {

552+ return true;

553+ };

554+ return false;

555+ };

556+ };

557+ var v2 = collapse(equalsP)(v1);

558+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytDeclGuard) {

559+ return insertToken(v)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1));

560+ };

561+ return insertDefault(v1);

562+ };

563+ if (v.value instanceof PureScript_CST_Types.TokPipe) {

564+ var v2 = collapse(offsideEndP)(v1);

565+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytOf) {

566+ return insertToken(v)(pushStack(v.range.start)(LytCaseGuard.value)(v2));

567+ };

568+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytLet) {

569+ return insertToken(v)(pushStack(v.range.start)(LytDeclGuard.value)(v2));

570+ };

571+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytLetStmt) {

572+ return insertToken(v)(pushStack(v.range.start)(LytDeclGuard.value)(v2));

573+ };

574+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytWhere) {

575+ return insertToken(v)(pushStack(v.range.start)(LytDeclGuard.value)(v2));

576+ };

577+ return insertDefault(v1);

578+ };

579+ if (v.value instanceof PureScript_CST_Types.TokTick) {

580+ var v2 = collapse(indentedP)(v1);

581+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytTick) {

582+ return insertToken(v)(new Data_Tuple.Tuple(v2.value0.value1, v2.value1));

583+ };

584+ return pushStack(v.range.start)(LytTick.value)(insertToken(v)(insertSep(collapse(offsideEndP)(v1))));

585+ };

586+ if (v.value instanceof PureScript_CST_Types.TokComma) {

587+ var v2 = collapse(indentedP)(v1);

588+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytBrace) {

589+ return pushStack(v.range.start)(LytProperty.value)(insertToken(v)(v2));

590+ };

591+ return insertToken(v)(v2);

592+ };

593+ if (v.value instanceof PureScript_CST_Types.TokDot) {

594+ var v2 = insertDefault(v1);

595+ if (v2.value0 instanceof Data_List_Types.Cons && v2.value0.value0.value1 instanceof LytForall) {

596+ return new Data_Tuple.Tuple(v2.value0.value1, v2.value1);

597+ };

598+ return pushStack(v.range.start)(LytProperty.value)(v2);

599+ };

600+ if (v.value instanceof PureScript_CST_Types.TokLeftParen) {

601+ return pushStack(v.range.start)(LytParen.value)(insertDefault(v1));

602+ };

603+ if (v.value instanceof PureScript_CST_Types.TokLeftBrace) {

604+ return pushStack(v.range.start)(LytProperty.value)(pushStack(v.range.start)(LytBrace.value)(insertDefault(v1)));

605+ };

606+ if (v.value instanceof PureScript_CST_Types.TokLeftSquare) {

607+ return pushStack(v.range.start)(LytSquare.value)(insertDefault(v1));

608+ };

609+ if (v.value instanceof PureScript_CST_Types.TokRightParen) {

610+ return insertToken(v)(popStack(function (v2) {

611+ return eq1(v2)(LytParen.value);

612+ })(collapse(indentedP)(v1)));

613+ };

614+ if (v.value instanceof PureScript_CST_Types.TokRightBrace) {

615+ return insertToken(v)(popStack(function (v2) {

616+ return eq1(v2)(LytBrace.value);

617+ })(popStack(function (v2) {

618+ return eq1(v2)(LytProperty.value);

619+ })(collapse(indentedP)(v1))));

620+ };

621+ if (v.value instanceof PureScript_CST_Types.TokRightSquare) {

622+ return insertToken(v)(popStack(function (v2) {

623+ return eq1(v2)(LytSquare.value);

624+ })(collapse(indentedP)(v1)));

625+ };

626+ if (v.value instanceof PureScript_CST_Types.TokString) {

627+ return popStack(function (v2) {

628+ return eq1(v2)(LytProperty.value);

629+ })(insertDefault(v1));

630+ };

631+ if (v.value instanceof PureScript_CST_Types.TokLowerName && v.value.value0 instanceof Data_Maybe.Nothing) {

632+ return popStack(function (v2) {

633+ return eq1(v2)(LytProperty.value);

634+ })(insertDefault(v1));

635+ };

636+ if (v.value instanceof PureScript_CST_Types.TokOperator) {

637+ return insertToken(v)(insertSep(collapse(offsideEndP)(v1)));

638+ };

639+ return insertDefault(v1);

640+ };

641+ return insert(new Data_Tuple.Tuple(stack, [ ]));

642+ };

643+ };

644+};

645+var ordLayoutDelim = {

646+ compare: function (x) {

647+ return function (y) {

648+ if (x instanceof LytRoot && y instanceof LytRoot) {

649+ return Data_Ordering.EQ.value;

650+ };

651+ if (x instanceof LytRoot) {

652+ return Data_Ordering.LT.value;

653+ };

654+ if (y instanceof LytRoot) {

655+ return Data_Ordering.GT.value;

656+ };

657+ if (x instanceof LytTopDecl && y instanceof LytTopDecl) {

658+ return Data_Ordering.EQ.value;

659+ };

660+ if (x instanceof LytTopDecl) {

661+ return Data_Ordering.LT.value;

662+ };

663+ if (y instanceof LytTopDecl) {

664+ return Data_Ordering.GT.value;

665+ };

666+ if (x instanceof LytTopDeclHead && y instanceof LytTopDeclHead) {

667+ return Data_Ordering.EQ.value;

668+ };

669+ if (x instanceof LytTopDeclHead) {

670+ return Data_Ordering.LT.value;

671+ };

672+ if (y instanceof LytTopDeclHead) {

673+ return Data_Ordering.GT.value;

674+ };

675+ if (x instanceof LytDeclGuard && y instanceof LytDeclGuard) {

676+ return Data_Ordering.EQ.value;

677+ };

678+ if (x instanceof LytDeclGuard) {

679+ return Data_Ordering.LT.value;

680+ };

681+ if (y instanceof LytDeclGuard) {

682+ return Data_Ordering.GT.value;

683+ };

684+ if (x instanceof LytCase && y instanceof LytCase) {

685+ return Data_Ordering.EQ.value;

686+ };

687+ if (x instanceof LytCase) {

688+ return Data_Ordering.LT.value;

689+ };

690+ if (y instanceof LytCase) {

691+ return Data_Ordering.GT.value;

692+ };

693+ if (x instanceof LytCaseBinders && y instanceof LytCaseBinders) {

694+ return Data_Ordering.EQ.value;

695+ };

696+ if (x instanceof LytCaseBinders) {

697+ return Data_Ordering.LT.value;

698+ };

699+ if (y instanceof LytCaseBinders) {

700+ return Data_Ordering.GT.value;

701+ };

702+ if (x instanceof LytCaseGuard && y instanceof LytCaseGuard) {

703+ return Data_Ordering.EQ.value;

704+ };

705+ if (x instanceof LytCaseGuard) {

706+ return Data_Ordering.LT.value;

707+ };

708+ if (y instanceof LytCaseGuard) {

709+ return Data_Ordering.GT.value;

710+ };

711+ if (x instanceof LytLambdaBinders && y instanceof LytLambdaBinders) {

712+ return Data_Ordering.EQ.value;

713+ };

714+ if (x instanceof LytLambdaBinders) {

715+ return Data_Ordering.LT.value;

716+ };

717+ if (y instanceof LytLambdaBinders) {

718+ return Data_Ordering.GT.value;

719+ };

720+ if (x instanceof LytParen && y instanceof LytParen) {

721+ return Data_Ordering.EQ.value;

722+ };

723+ if (x instanceof LytParen) {

724+ return Data_Ordering.LT.value;

725+ };

726+ if (y instanceof LytParen) {

727+ return Data_Ordering.GT.value;

728+ };

729+ if (x instanceof LytBrace && y instanceof LytBrace) {

730+ return Data_Ordering.EQ.value;

731+ };

732+ if (x instanceof LytBrace) {

733+ return Data_Ordering.LT.value;

734+ };

735+ if (y instanceof LytBrace) {

736+ return Data_Ordering.GT.value;

737+ };

738+ if (x instanceof LytSquare && y instanceof LytSquare) {

739+ return Data_Ordering.EQ.value;

740+ };

741+ if (x instanceof LytSquare) {

742+ return Data_Ordering.LT.value;

743+ };

744+ if (y instanceof LytSquare) {

745+ return Data_Ordering.GT.value;

746+ };

747+ if (x instanceof LytIf && y instanceof LytIf) {

748+ return Data_Ordering.EQ.value;

749+ };

750+ if (x instanceof LytIf) {

751+ return Data_Ordering.LT.value;

752+ };

753+ if (y instanceof LytIf) {

754+ return Data_Ordering.GT.value;

755+ };

756+ if (x instanceof LytThen && y instanceof LytThen) {

757+ return Data_Ordering.EQ.value;

758+ };

759+ if (x instanceof LytThen) {

760+ return Data_Ordering.LT.value;

761+ };

762+ if (y instanceof LytThen) {

763+ return Data_Ordering.GT.value;

764+ };

765+ if (x instanceof LytProperty && y instanceof LytProperty) {

766+ return Data_Ordering.EQ.value;

767+ };

768+ if (x instanceof LytProperty) {

769+ return Data_Ordering.LT.value;

770+ };

771+ if (y instanceof LytProperty) {

772+ return Data_Ordering.GT.value;

773+ };

774+ if (x instanceof LytForall && y instanceof LytForall) {

775+ return Data_Ordering.EQ.value;

776+ };

777+ if (x instanceof LytForall) {

778+ return Data_Ordering.LT.value;

779+ };

780+ if (y instanceof LytForall) {

781+ return Data_Ordering.GT.value;

782+ };

783+ if (x instanceof LytTick && y instanceof LytTick) {

784+ return Data_Ordering.EQ.value;

785+ };

786+ if (x instanceof LytTick) {

787+ return Data_Ordering.LT.value;

788+ };

789+ if (y instanceof LytTick) {

790+ return Data_Ordering.GT.value;

791+ };

792+ if (x instanceof LytLet && y instanceof LytLet) {

793+ return Data_Ordering.EQ.value;

794+ };

795+ if (x instanceof LytLet) {

796+ return Data_Ordering.LT.value;

797+ };

798+ if (y instanceof LytLet) {

799+ return Data_Ordering.GT.value;

800+ };

801+ if (x instanceof LytLetStmt && y instanceof LytLetStmt) {

802+ return Data_Ordering.EQ.value;

803+ };

804+ if (x instanceof LytLetStmt) {

805+ return Data_Ordering.LT.value;

806+ };

807+ if (y instanceof LytLetStmt) {

808+ return Data_Ordering.GT.value;

809+ };

810+ if (x instanceof LytWhere && y instanceof LytWhere) {

811+ return Data_Ordering.EQ.value;

812+ };

813+ if (x instanceof LytWhere) {

814+ return Data_Ordering.LT.value;

815+ };

816+ if (y instanceof LytWhere) {

817+ return Data_Ordering.GT.value;

818+ };

819+ if (x instanceof LytOf && y instanceof LytOf) {

820+ return Data_Ordering.EQ.value;

821+ };

822+ if (x instanceof LytOf) {

823+ return Data_Ordering.LT.value;

824+ };

825+ if (y instanceof LytOf) {

826+ return Data_Ordering.GT.value;

827+ };

828+ if (x instanceof LytDo && y instanceof LytDo) {

829+ return Data_Ordering.EQ.value;

830+ };

831+ if (x instanceof LytDo) {

832+ return Data_Ordering.LT.value;

833+ };

834+ if (y instanceof LytDo) {

835+ return Data_Ordering.GT.value;

836+ };

837+ if (x instanceof LytAdo && y instanceof LytAdo) {

838+ return Data_Ordering.EQ.value;

839+ };

840+ throw new Error("Failed pattern match at PureScript.CST.Layout (line 0, column 0 - line 0, column 0): " + [ x.constructor.name, y.constructor.name ]);

841+ };

842+ },

843+ Eq0: function () {

844+ return eqLayoutDelim;

845+ }

846+};

847+var currentIndent = /* #__PURE__ */ (function () {

848+ var go = function ($copy_v) {

849+ var $tco_done = false;

850+ var $tco_result;

851+ function $tco_loop(v) {

852+ if (v instanceof Data_List_Types.Cons) {

853+ if (isIndented(v.value0.value1)) {

854+ $tco_done = true;

855+ return new Data_Maybe.Just(v.value0.value0);

856+ };

857+ if (Data_Boolean.otherwise) {

858+ $copy_v = v.value1;

859+ return;

860+ };

861+ };

862+ $tco_done = true;

863+ return Data_Maybe.Nothing.value;

864+ };

865+ while (!$tco_done) {

866+ $tco_result = $tco_loop($copy_v);

867+ };

868+ return $tco_result;

869+ };

870+ return go;

871+})();

872+export {

873+ LytRoot,

874+ LytTopDecl,

875+ LytTopDeclHead,

876+ LytDeclGuard,

877+ LytCase,

878+ LytCaseBinders,

879+ LytCaseGuard,

880+ LytLambdaBinders,

881+ LytParen,

882+ LytBrace,

883+ LytSquare,

884+ LytIf,

885+ LytThen,

886+ LytProperty,

887+ LytForall,

888+ LytTick,

889+ LytLet,

890+ LytLetStmt,

891+ LytWhere,

892+ LytOf,

893+ LytDo,

894+ LytAdo,

895+ currentIndent,

896+ isIndented,

897+ insertLayout,

898+ lytToken,

899+ eqLayoutDelim,

900+ ordLayoutDelim

901+};

output-compile-fail/PureScript.CST.Lexer/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Lexer/index.jsnew file+1092

@@ -0,0 +1,1092 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Alt from "../Control.Alt/index.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Control_Apply from "../Control.Apply/index.js";

5+import * as Control_Bind from "../Control.Bind/index.js";

6+import * as Control_Category from "../Control.Category/index.js";

7+import * as Data_Array from "../Data.Array/index.js";

8+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

9+import * as Data_Array_ST from "../Data.Array.ST/index.js";

10+import * as Data_Boolean from "../Data.Boolean/index.js";

11+import * as Data_Char from "../Data.Char/index.js";

12+import * as Data_Either from "../Data.Either/index.js";

13+import * as Data_Enum from "../Data.Enum/index.js";

14+import * as Data_EuclideanRing from "../Data.EuclideanRing/index.js";

15+import * as Data_Foldable from "../Data.Foldable/index.js";

16+import * as Data_Function from "../Data.Function/index.js";

17+import * as Data_Functor from "../Data.Functor/index.js";

18+import * as Data_Int from "../Data.Int/index.js";

19+import * as Data_Lazy from "../Data.Lazy/index.js";

20+import * as Data_List_Types from "../Data.List.Types/index.js";

21+import * as Data_Maybe from "../Data.Maybe/index.js";

22+import * as Data_Monoid from "../Data.Monoid/index.js";

23+import * as Data_Newtype from "../Data.Newtype/index.js";

24+import * as Data_Number from "../Data.Number/index.js";

25+import * as Data_Semigroup from "../Data.Semigroup/index.js";

26+import * as Data_Semiring from "../Data.Semiring/index.js";

27+import * as Data_String_CodePoints from "../Data.String.CodePoints/index.js";

28+import * as Data_String_CodeUnits from "../Data.String.CodeUnits/index.js";

29+import * as Data_String_Common from "../Data.String.Common/index.js";

30+import * as Data_String_Regex from "../Data.String.Regex/index.js";

31+import * as Data_String_Regex_Flags from "../Data.String.Regex.Flags/index.js";

32+import * as Data_String_Regex_Unsafe from "../Data.String.Regex.Unsafe/index.js";

33+import * as Data_Tuple from "../Data.Tuple/index.js";

34+import * as Data_Unit from "../Data.Unit/index.js";

35+import * as Partial_Unsafe from "../Partial.Unsafe/index.js";

36+import * as PureScript_CST_Errors from "../PureScript.CST.Errors/index.js";

37+import * as PureScript_CST_Layout from "../PureScript.CST.Layout/index.js";

38+import * as PureScript_CST_TokenStream from "../PureScript.CST.TokenStream/index.js";

39+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

40+var add = /* #__PURE__ */ Data_Semiring.add(Data_Semiring.semiringInt);

41+var div = /* #__PURE__ */ Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt);

42+var foldMap = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableArray)(Data_Monoid.monoidArray);

43+var bindFlipped = /* #__PURE__ */ Control_Bind.bindFlipped(Data_Maybe.bindMaybe);

44+var foldMap1 = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString);

45+var fold = /* #__PURE__ */ Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString);

46+var fold1 = /* #__PURE__ */ Data_Foldable.fold(Data_Foldable.foldableArray)(/* #__PURE__ */ Data_Monoid.monoidRecord()(/* #__PURE__ */ Data_Monoid.monoidRecordCons({

47+ reflectSymbol: function () {

48+ return "raw";

49+ }

50+})(Data_Monoid.monoidString)()(/* #__PURE__ */ Data_Monoid.monoidRecordCons({

51+ reflectSymbol: function () {

52+ return "string";

53+ }

54+})(Data_Monoid.monoidString)()(Data_Monoid.monoidRecordNil))));

55+var foldl = /* #__PURE__ */ Data_Foldable.foldl(Data_Foldable.foldableArray);

56+var consTokens = /* #__PURE__ */ PureScript_CST_TokenStream.consTokens(Data_Foldable.foldableArray);

57+var LexFail = /* #__PURE__ */ (function () {

58+ function LexFail(value0, value1) {

59+ this.value0 = value0;

60+ this.value1 = value1;

61+ };

62+ LexFail.create = function (value0) {

63+ return function (value1) {

64+ return new LexFail(value0, value1);

65+ };

66+ };

67+ return LexFail;

68+})();

69+var LexSucc = /* #__PURE__ */ (function () {

70+ function LexSucc(value0, value1) {

71+ this.value0 = value0;

72+ this.value1 = value1;

73+ };

74+ LexSucc.create = function (value0) {

75+ return function (value1) {

76+ return new LexSucc(value0, value1);

77+ };

78+ };

79+ return LexSucc;

80+})();

81+var Lex = function (x) {

82+ return x;

83+};

84+var isCharCodePoint = {

85+ fromChar: Data_String_CodePoints.codePointFromChar,

86+ fromCharCode: /* #__PURE__ */ Data_Enum.toEnum(Data_String_CodePoints.boundedEnumCodePoint)

87+};

88+var isCharChar = {

89+ fromChar: /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn),

90+ fromCharCode: Data_Char.fromCharCode

91+};

92+var $$try = function (v) {

93+ return function (str) {

94+ var v1 = v(str);

95+ if (v1 instanceof LexFail) {

96+ return new LexFail(v1.value0, str);

97+ };

98+ if (v1 instanceof LexSucc) {

99+ return new LexSucc(v1.value0, v1.value1);

100+ };

101+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 104, column 3 - line 106, column 31): " + [ v1.constructor.name ]);

102+ };

103+};

104+var toModuleName = function (v) {

105+ if (v === "") {

106+ return Data_Maybe.Nothing.value;

107+ };

108+ return new Data_Maybe.Just(Data_String_CodeUnits.dropRight(1)(v));

109+};

110+var qualLength = /* #__PURE__ */ Data_Maybe.maybe(0)(/* #__PURE__ */ (function () {

111+ var $319 = add(1);

112+ var $320 = Data_Newtype.unwrap();

113+ return function ($321) {

114+ return $319(Data_String_CodePoints.length($320($321)));

115+ };

116+})());

117+var optional = function (v) {

118+ return function (str) {

119+ var v1 = v(str);

120+ if (v1 instanceof LexFail) {

121+ if (Data_String_CodeUnits.length(str) === Data_String_CodeUnits.length(v1.value1)) {

122+ return new LexSucc(Data_Maybe.Nothing.value, str);

123+ };

124+ if (Data_Boolean.otherwise) {

125+ return new LexFail(v1.value0, v1.value1);

126+ };

127+ };

128+ if (v1 instanceof LexSucc) {

129+ return new LexSucc(new Data_Maybe.Just(v1.value0), v1.value1);

130+ };

131+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 153, column 3 - line 160, column 25): " + [ v1.constructor.name ]);

132+ };

133+};

134+var mkUnexpected = function (str) {

135+ var start = Data_String_CodePoints.take(6)(str);

136+ var len = Data_String_CodePoints.length(start);

137+ var $148 = len === 0;

138+ if ($148) {

139+ return "end of file";

140+ };

141+ var $149 = len < 6;

142+ if ($149) {

143+ return start;

144+ };

145+ return start + "...";

146+};

147+var regex = function (mkErr) {

148+ return function (regexStr) {

149+ var matchRegex = Data_String_Regex_Unsafe.unsafeRegex("^(?:" + (regexStr + ")"))(Data_String_Regex_Flags.unicode);

150+ return function (str) {

151+ var v = Data_String_Regex.match(matchRegex)(str);

152+ var v1 = function (v2) {

153+ return new LexFail(function (v3) {

154+ return mkErr(mkUnexpected(str));

155+ }, str);

156+ };

157+ if (v instanceof Data_Maybe.Just) {

158+ var $151 = Data_Array_NonEmpty.head(v.value0);

159+ if ($151 instanceof Data_Maybe.Just) {

160+ return new LexSucc($151.value0, Data_String_CodeUnits.drop(Data_String_CodeUnits.length($151.value0))(str));

161+ };

162+ return v1(true);

163+ };

164+ return v1(true);

165+ };

166+ };

167+};

168+var shebangComment = /* #__PURE__ */ (function () {

169+ return regex(PureScript_CST_Errors.LexExpected.create("shebang"))("#![^\\r\\n]*");

170+})();

171+var satisfy = function (mkErr) {

172+ return function (p) {

173+ return function (str) {

174+ var v = Data_String_CodeUnits.charAt(0)(str);

175+ if (v instanceof Data_Maybe.Just && p(v.value0)) {

176+ return new LexSucc(v.value0, Data_String_CodeUnits.drop(1)(str));

177+ };

178+ return new LexFail(function (v1) {

179+ return mkErr(mkUnexpected(str));

180+ }, str);

181+ };

182+ };

183+};

184+var string = function (mkErr) {

185+ return function (match) {

186+ return function (str) {

187+ var $156 = Data_String_CodeUnits.take(Data_String_CodeUnits.length(match))(str) === match;

188+ if ($156) {

189+ return new LexSucc(match, Data_String_CodeUnits.drop(Data_String_CodeUnits.length(match))(str));

190+ };

191+ return new LexFail(function (v) {

192+ return mkErr(mkUnexpected(str));

193+ }, str);

194+ };

195+ };

196+};

197+var many = function (v) {

198+ return function (str) {

199+ return (function __do() {

200+ var valuesRef = Data_Array_ST["new"]();

201+ var strRef = str;

202+ var contRef = true;

203+ var resRef = new LexSucc([ ], str);

204+ (function () {

205+ while (contRef) {

206+ (function __do() {

207+ var str$prime = strRef;

208+ var v1 = v(str$prime);

209+ if (v1 instanceof LexFail) {

210+ if (Data_String_CodeUnits.length(str$prime) === Data_String_CodeUnits.length(v1.value1)) {

211+ var values = Data_Array_ST.unsafeFreeze(valuesRef)();

212+ resRef = new LexSucc(values, v1.value1);

213+ contRef = false;

214+ return Data_Unit.unit;

215+ };

216+ if (Data_Boolean.otherwise) {

217+ resRef = new LexFail(v1.value0, v1.value1);

218+ contRef = false;

219+ return Data_Unit.unit;

220+ };

221+ };

222+ if (v1 instanceof LexSucc) {

223+ Data_Array_ST.push(v1.value0)(valuesRef)();

224+ strRef = v1.value1;

225+ return Data_Unit.unit;

226+ };

227+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 178, column 5 - line 192, column 18): " + [ v1.constructor.name ]);

228+ })();

229+ };

230+ return {};

231+ })();

232+ return resRef;

233+ })();

234+ };

235+};

236+var functorLex = {

237+ map: function (f) {

238+ return function (v) {

239+ return function (str) {

240+ var v1 = v(str);

241+ if (v1 instanceof LexFail) {

242+ return new LexFail(v1.value0, v1.value1);

243+ };

244+ if (v1 instanceof LexSucc) {

245+ return new LexSucc(f(v1.value0), v1.value1);

246+ };

247+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 66, column 5 - line 68, column 37): " + [ v1.constructor.name ]);

248+ };

249+ };

250+ }

251+};

252+var map = /* #__PURE__ */ Data_Functor.map(functorLex);

253+var spaceComment = /* #__PURE__ */ (function () {

254+ return map(Data_String_CodeUnits.length)(regex(PureScript_CST_Errors.LexExpected.create("spaces"))(" +"));

255+})();

256+var fromCharCode = function (dict) {

257+ return dict.fromCharCode;

258+};

259+var fromChar = function (dict) {

260+ return dict.fromChar;

261+};

262+var fail = function ($322) {

263+ return Lex(LexFail.create(Data_Function["const"]($322)));

264+};

265+var char$prime = function (mkErr) {

266+ return function (res) {

267+ return function (match) {

268+ return function (str) {

269+ var $172 = Data_String_CodeUnits.singleton(match) === Data_String_CodeUnits.take(1)(str);

270+ if ($172) {

271+ return new LexSucc(res, Data_String_CodeUnits.drop(1)(str));

272+ };

273+ return new LexFail(function (v) {

274+ return mkErr(mkUnexpected(str));

275+ }, str);

276+ };

277+ };

278+ };

279+};

280+var $$char = function (mkErr) {

281+ return function (match) {

282+ return function (str) {

283+ var $173 = Data_String_CodeUnits.singleton(match) === Data_String_CodeUnits.take(1)(str);

284+ if ($173) {

285+ return new LexSucc(match, Data_String_CodeUnits.drop(1)(str));

286+ };

287+ return new LexFail(function (v) {

288+ return mkErr(mkUnexpected(str));

289+ }, str);

290+ };

291+ };

292+};

293+var bumpText = function (v) {

294+ return function (colOffset) {

295+ return function (str) {

296+ var go = function ($copy_n) {

297+ return function ($copy_ix) {

298+ var $tco_var_n = $copy_n;

299+ var $tco_done = false;

300+ var $tco_result;

301+ function $tco_loop(n, ix) {

302+ var v1 = Data_String_CodeUnits["indexOf$prime"]("\x0a")(ix)(str);

303+ if (v1 instanceof Data_Maybe.Just) {

304+ $tco_var_n = n + 1 | 0;

305+ $copy_ix = v1.value0 + 1 | 0;

306+ return;

307+ };

308+ if (v1 instanceof Data_Maybe.Nothing) {

309+ if (n === 0) {

310+ $tco_done = true;

311+ return {

312+ line: v.line,

313+ column: (v.column + Data_String_CodePoints.length(str) | 0) + (colOffset * 2 | 0) | 0

314+ };

315+ };

316+ if (Data_Boolean.otherwise) {

317+ $tco_done = true;

318+ return {

319+ line: v.line + n | 0,

320+ column: Data_String_CodePoints.length(Data_String_CodeUnits.drop(ix)(str)) + colOffset | 0

321+ };

322+ };

323+ };

324+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 348, column 13 - line 357, column 12): " + [ v1.constructor.name ]);

325+ };

326+ while (!$tco_done) {

327+ $tco_result = $tco_loop($tco_var_n, $copy_ix);

328+ };

329+ return $tco_result;

330+ };

331+ };

332+ return go(0)(0);

333+ };

334+ };

335+};

336+var bumpToken = function (v) {

337+ return function (v1) {

338+ if (v1 instanceof PureScript_CST_Types.TokLeftParen) {

339+ return {

340+ line: v.line,

341+ column: v.column + 1 | 0

342+ };

343+ };

344+ if (v1 instanceof PureScript_CST_Types.TokRightParen) {

345+ return {

346+ line: v.line,

347+ column: v.column + 1 | 0

348+ };

349+ };

350+ if (v1 instanceof PureScript_CST_Types.TokLeftBrace) {

351+ return {

352+ line: v.line,

353+ column: v.column + 1 | 0

354+ };

355+ };

356+ if (v1 instanceof PureScript_CST_Types.TokRightBrace) {

357+ return {

358+ line: v.line,

359+ column: v.column + 1 | 0

360+ };

361+ };

362+ if (v1 instanceof PureScript_CST_Types.TokLeftSquare) {

363+ return {

364+ line: v.line,

365+ column: v.column + 1 | 0

366+ };

367+ };

368+ if (v1 instanceof PureScript_CST_Types.TokRightSquare) {

369+ return {

370+ line: v.line,

371+ column: v.column + 1 | 0

372+ };

373+ };

374+ if (v1 instanceof PureScript_CST_Types.TokLeftArrow && v1.value0 instanceof PureScript_CST_Types.ASCII) {

375+ return {

376+ line: v.line,

377+ column: v.column + 2 | 0

378+ };

379+ };

380+ if (v1 instanceof PureScript_CST_Types.TokLeftArrow && v1.value0 instanceof PureScript_CST_Types.Unicode) {

381+ return {

382+ line: v.line,

383+ column: v.column + 1 | 0

384+ };

385+ };

386+ if (v1 instanceof PureScript_CST_Types.TokRightArrow && v1.value0 instanceof PureScript_CST_Types.ASCII) {

387+ return {

388+ line: v.line,

389+ column: v.column + 2 | 0

390+ };

391+ };

392+ if (v1 instanceof PureScript_CST_Types.TokRightArrow && v1.value0 instanceof PureScript_CST_Types.Unicode) {

393+ return {

394+ line: v.line,

395+ column: v.column + 1 | 0

396+ };

397+ };

398+ if (v1 instanceof PureScript_CST_Types.TokRightFatArrow && v1.value0 instanceof PureScript_CST_Types.ASCII) {

399+ return {

400+ line: v.line,

401+ column: v.column + 2 | 0

402+ };

403+ };

404+ if (v1 instanceof PureScript_CST_Types.TokRightFatArrow && v1.value0 instanceof PureScript_CST_Types.Unicode) {

405+ return {

406+ line: v.line,

407+ column: v.column + 1 | 0

408+ };

409+ };

410+ if (v1 instanceof PureScript_CST_Types.TokDoubleColon && v1.value0 instanceof PureScript_CST_Types.ASCII) {

411+ return {

412+ line: v.line,

413+ column: v.column + 2 | 0

414+ };

415+ };

416+ if (v1 instanceof PureScript_CST_Types.TokDoubleColon && v1.value0 instanceof PureScript_CST_Types.Unicode) {

417+ return {

418+ line: v.line,

419+ column: v.column + 1 | 0

420+ };

421+ };

422+ if (v1 instanceof PureScript_CST_Types.TokForall && v1.value0 instanceof PureScript_CST_Types.ASCII) {

423+ return {

424+ line: v.line,

425+ column: v.column + 6 | 0

426+ };

427+ };

428+ if (v1 instanceof PureScript_CST_Types.TokForall && v1.value0 instanceof PureScript_CST_Types.Unicode) {

429+ return {

430+ line: v.line,

431+ column: v.column + 1 | 0

432+ };

433+ };

434+ if (v1 instanceof PureScript_CST_Types.TokEquals) {

435+ return {

436+ line: v.line,

437+ column: v.column + 1 | 0

438+ };

439+ };

440+ if (v1 instanceof PureScript_CST_Types.TokPipe) {

441+ return {

442+ line: v.line,

443+ column: v.column + 1 | 0

444+ };

445+ };

446+ if (v1 instanceof PureScript_CST_Types.TokTick) {

447+ return {

448+ line: v.line,

449+ column: v.column + 1 | 0

450+ };

451+ };

452+ if (v1 instanceof PureScript_CST_Types.TokDot) {

453+ return {

454+ line: v.line,

455+ column: v.column + 1 | 0

456+ };

457+ };

458+ if (v1 instanceof PureScript_CST_Types.TokComma) {

459+ return {

460+ line: v.line,

461+ column: v.column + 1 | 0

462+ };

463+ };

464+ if (v1 instanceof PureScript_CST_Types.TokUnderscore) {

465+ return {

466+ line: v.line,

467+ column: v.column + 1 | 0

468+ };

469+ };

470+ if (v1 instanceof PureScript_CST_Types.TokBackslash) {

471+ return {

472+ line: v.line,

473+ column: v.column + 1 | 0

474+ };

475+ };

476+ if (v1 instanceof PureScript_CST_Types.TokAt) {

477+ return {

478+ line: v.line,

479+ column: v.column + 1 | 0

480+ };

481+ };

482+ if (v1 instanceof PureScript_CST_Types.TokLowerName) {

483+ return {

484+ line: v.line,

485+ column: (v.column + qualLength(v1.value0) | 0) + Data_String_CodePoints.length(v1.value1) | 0

486+ };

487+ };

488+ if (v1 instanceof PureScript_CST_Types.TokUpperName) {

489+ return {

490+ line: v.line,

491+ column: (v.column + qualLength(v1.value0) | 0) + Data_String_CodePoints.length(v1.value1) | 0

492+ };

493+ };

494+ if (v1 instanceof PureScript_CST_Types.TokOperator) {

495+ return {

496+ line: v.line,

497+ column: (v.column + qualLength(v1.value0) | 0) + Data_String_CodePoints.length(v1.value1) | 0

498+ };

499+ };

500+ if (v1 instanceof PureScript_CST_Types.TokSymbolName) {

501+ return {

502+ line: v.line,

503+ column: ((v.column + qualLength(v1.value0) | 0) + Data_String_CodePoints.length(v1.value1) | 0) + 2 | 0

504+ };

505+ };

506+ if (v1 instanceof PureScript_CST_Types.TokSymbolArrow && v1.value0 instanceof PureScript_CST_Types.Unicode) {

507+ return {

508+ line: v.line,

509+ column: v.column + 3 | 0

510+ };

511+ };

512+ if (v1 instanceof PureScript_CST_Types.TokSymbolArrow && v1.value0 instanceof PureScript_CST_Types.ASCII) {

513+ return {

514+ line: v.line,

515+ column: v.column + 4 | 0

516+ };

517+ };

518+ if (v1 instanceof PureScript_CST_Types.TokHole) {

519+ return {

520+ line: v.line,

521+ column: (v.column + Data_String_CodePoints.length(v1.value0) | 0) + 1 | 0

522+ };

523+ };

524+ if (v1 instanceof PureScript_CST_Types.TokChar) {

525+ return {

526+ line: v.line,

527+ column: (v.column + Data_String_CodePoints.length(v1.value0) | 0) + 2 | 0

528+ };

529+ };

530+ if (v1 instanceof PureScript_CST_Types.TokInt) {

531+ return {

532+ line: v.line,

533+ column: v.column + Data_String_CodePoints.length(v1.value0) | 0

534+ };

535+ };

536+ if (v1 instanceof PureScript_CST_Types.TokNumber) {

537+ return {

538+ line: v.line,

539+ column: v.column + Data_String_CodePoints.length(v1.value0) | 0

540+ };

541+ };

542+ if (v1 instanceof PureScript_CST_Types.TokString) {

543+ return bumpText(v)(1)(v1.value0);

544+ };

545+ if (v1 instanceof PureScript_CST_Types.TokRawString) {

546+ return bumpText(v)(3)(v1.value0);

547+ };

548+ if (v1 instanceof PureScript_CST_Types.TokLayoutStart) {

549+ return v;

550+ };

551+ if (v1 instanceof PureScript_CST_Types.TokLayoutSep) {

552+ return v;

553+ };

554+ if (v1 instanceof PureScript_CST_Types.TokLayoutEnd) {

555+ return v;

556+ };

557+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 265, column 34 - line 343, column 8): " + [ v1.constructor.name ]);

558+ };

559+};

560+var bumpComment = function (v) {

561+ return function (v1) {

562+ if (v1 instanceof PureScript_CST_Types.Comment) {

563+ return bumpText(v)(0)(v1.value0);

564+ };

565+ if (v1 instanceof PureScript_CST_Types.Space) {

566+ return {

567+ line: v.line,

568+ column: v.column + v1.value0 | 0

569+ };

570+ };

571+ if (v1 instanceof PureScript_CST_Types.Line) {

572+ return {

573+ line: v.line + v1.value1 | 0,

574+ column: 0

575+ };

576+ };

577+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 360, column 36 - line 366, column 34): " + [ v1.constructor.name ]);

578+ };

579+};

580+var applyLex = {

581+ apply: function (v) {

582+ return function (v1) {

583+ return function (str) {

584+ var v2 = v(str);

585+ if (v2 instanceof LexFail) {

586+ return new LexFail(v2.value0, v2.value1);

587+ };

588+ if (v2 instanceof LexSucc) {

589+ var v3 = v1(v2.value1);

590+ if (v3 instanceof LexFail) {

591+ return new LexFail(v3.value0, v3.value1);

592+ };

593+ if (v3 instanceof LexSucc) {

594+ return new LexSucc(v2.value0(v3.value0), v3.value1);

595+ };

596+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 75, column 9 - line 78, column 32): " + [ v3.constructor.name ]);

597+ };

598+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 72, column 5 - line 78, column 32): " + [ v2.constructor.name ]);

599+ };

600+ };

601+ },

602+ Functor0: function () {

603+ return functorLex;

604+ }

605+};

606+var apply = /* #__PURE__ */ Control_Apply.apply(applyLex);

607+var applyFirst = /* #__PURE__ */ Control_Apply.applyFirst(applyLex);

608+var applySecond = /* #__PURE__ */ Control_Apply.applySecond(applyLex);

609+var bindLex = {

610+ bind: function (v) {

611+ return function (k) {

612+ return function (str) {

613+ var v1 = v(str);

614+ if (v1 instanceof LexFail) {

615+ return new LexFail(v1.value0, v1.value1);

616+ };

617+ if (v1 instanceof LexSucc) {

618+ var v2 = k(v1.value0);

619+ return v2(v1.value1);

620+ };

621+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 85, column 5 - line 89, column 16): " + [ v1.constructor.name ]);

622+ };

623+ };

624+ },

625+ Apply0: function () {

626+ return applyLex;

627+ }

628+};

629+var bind1 = /* #__PURE__ */ Control_Bind.bind(bindLex);

630+var applicativeLex = {

631+ pure: function ($323) {

632+ return Lex(LexSucc.create($323));

633+ },

634+ Apply0: function () {

635+ return applyLex;

636+ }

637+};

638+var pure1 = /* #__PURE__ */ Control_Applicative.pure(applicativeLex);

639+var altLex = {

640+ alt: function (v) {

641+ return function (v1) {

642+ return function (str) {

643+ var v2 = v(str);

644+ if (v2 instanceof LexFail) {

645+ if (Data_String_CodeUnits.length(str) === Data_String_CodeUnits.length(v2.value1)) {

646+ return v1(str);

647+ };

648+ if (Data_Boolean.otherwise) {

649+ return new LexFail(v2.value0, v2.value1);

650+ };

651+ };

652+ if (v2 instanceof LexSucc) {

653+ return new LexSucc(v2.value0, v2.value1);

654+ };

655+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 93, column 5 - line 100, column 20): " + [ v2.constructor.name ]);

656+ };

657+ };

658+ },

659+ Functor0: function () {

660+ return functorLex;

661+ }

662+};

663+var alt = /* #__PURE__ */ Control_Alt.alt(altLex);

664+var comment = /* #__PURE__ */ (function () {

665+ return alt(regex(PureScript_CST_Errors.LexExpected.create("block comment"))("\\{-(-(?!\\})|[^-]+)*(-\\}|$)"))(regex(PureScript_CST_Errors.LexExpected.create("line comment"))("--[^\\r\\n]*"));

666+})();

667+var lineComment = /* #__PURE__ */ (function () {

668+ return alt(map((function () {

669+ var $324 = PureScript_CST_Types.Line.create(PureScript_CST_Types.LF.value);

670+ return function ($325) {

671+ return $324(Data_String_CodePoints.length($325));

672+ };

673+ })())(regex(PureScript_CST_Errors.LexExpected.create("newline"))("\x0a+")))(map((function () {

674+ var $326 = PureScript_CST_Types.Line.create(PureScript_CST_Types.CRLF.value);

675+ return function ($327) {

676+ return $326((function (v) {

677+ return div(v)(2);

678+ })(Data_String_CodePoints.length($327)));

679+ };

680+ })())(regex(PureScript_CST_Errors.LexExpected.create("newline"))("(?:\x0d\x0a)+")));

681+})();

682+var leadingComments = /* #__PURE__ */ (function () {

683+ return many(alt(map(PureScript_CST_Types.Comment.create)(comment))(alt(map(PureScript_CST_Types.Space.create)(spaceComment))(lineComment)));

684+})();

685+var oneLineComment = /* #__PURE__ */ bind1(lineComment)(function (line) {

686+ if (line instanceof PureScript_CST_Types.Line && line.value1 === 1) {

687+ return pure1(line);

688+ };

689+ return fail(new PureScript_CST_Errors.LexExpected("one newline", "multiple newlines"));

690+});

691+var leadingShebangs = /* #__PURE__ */ (function () {

692+ return apply(map(function (v) {

693+ return function (v1) {

694+ return Data_Array.cons(new PureScript_CST_Types.Comment(v))(foldMap(function (v2) {

695+ return [ v2.value0, new PureScript_CST_Types.Comment(v2.value1) ];

696+ })(v1));

697+ };

698+ })(shebangComment))(many($$try(apply(map(Data_Tuple.Tuple.create)(oneLineComment))(shebangComment))));

699+})();

700+var leadingModuleComments = /* #__PURE__ */ apply(/* #__PURE__ */ map(/* #__PURE__ */ Data_Semigroup.append(Data_Semigroup.semigroupArray))(/* #__PURE__ */ alt(leadingShebangs)(/* #__PURE__ */ pure1([ ]))))(leadingComments);

701+var token = /* #__PURE__ */ (function () {

702+ var tokenTick = char$prime(PureScript_CST_Errors.LexExpected.create("backtick"))(PureScript_CST_Types.TokTick.value)("`");

703+ var tokenRightSquare = char$prime(PureScript_CST_Errors.LexExpected.create("right square"))(PureScript_CST_Types.TokRightSquare.value)("]");

704+ var tokenRightParen = char$prime(PureScript_CST_Errors.LexExpected.create("right paren"))(PureScript_CST_Types.TokRightParen.value)(")");

705+ var tokenRightBrace = char$prime(PureScript_CST_Errors.LexExpected.create("right brace"))(PureScript_CST_Types.TokRightBrace.value)("}");

706+ var tokenLeftSquare = char$prime(PureScript_CST_Errors.LexExpected.create("left square"))(PureScript_CST_Types.TokLeftSquare.value)("[");

707+ var tokenLeftParen = char$prime(PureScript_CST_Errors.LexExpected.create("left paren"))(PureScript_CST_Types.TokLeftParen.value)("(");

708+ var tokenLeftBrace = char$prime(PureScript_CST_Errors.LexExpected.create("left brace"))(PureScript_CST_Types.TokLeftBrace.value)("{");

709+ var tokenComma = char$prime(PureScript_CST_Errors.LexExpected.create("comma"))(PureScript_CST_Types.TokComma.value)(",");

710+ var stripUnderscores = Data_String_Common.replaceAll("_")("");

711+ var stringSpaceEscapeRegex = regex(PureScript_CST_Errors.LexExpected.create("whitespace escape"))("\\\\[ \\r\\n]+\\\\");

712+ var stringCharsRegex = regex(PureScript_CST_Errors.LexExpected.create("string characters"))("[^\"\\\\]+");

713+ var rawStringCharsRegex = regex(PureScript_CST_Errors.LexExpected.create("raw string characters"))("\"\"\"\"{0,2}([^\"]+\"{1,2})*[^\"]*\"\"\"");

714+ var parseSymbolIdent = regex(PureScript_CST_Errors.LexExpected.create("symbol"))("(?:[:!#$%&*+./<=>?@\\\\^|~-]|(?!\\p{P})\\p{S})+");

715+ var parseSymbol = map(function (v) {

716+ return function (v1) {

717+ if (v1 instanceof Data_Maybe.Nothing) {

718+ if (v === "->") {

719+ return new PureScript_CST_Types.TokSymbolArrow(PureScript_CST_Types.ASCII.value);

720+ };

721+ if (v === "\u2192") {

722+ return new PureScript_CST_Types.TokSymbolArrow(PureScript_CST_Types.Unicode.value);

723+ };

724+ return new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, v);

725+ };

726+ return new PureScript_CST_Types.TokSymbolName(v1, v);

727+ };

728+ })($$try(applyFirst(applySecond(tokenLeftParen)(parseSymbolIdent))(tokenRightParen)));

729+ var parseStringSpaceEscape = map(function (v) {

730+ return {

731+ raw: v,

732+ string: ""

733+ };

734+ })(stringSpaceEscapeRegex);

735+ var parseStringChars = map(function (v) {

736+ return {

737+ raw: v,

738+ string: v

739+ };

740+ })(stringCharsRegex);

741+ var parseRawString = map(function (v) {

742+ return new PureScript_CST_Types.TokRawString(Data_String_CodeUnits.dropRight(3)(Data_String_CodeUnits.drop(3)(v)));

743+ })(rawStringCharsRegex);

744+ var parseProper = regex(PureScript_CST_Errors.LexExpected.create("proper name"))("\\p{Lu}[\\p{L}0-9_']*");

745+ var parseUpper = map(Data_Function.flip(PureScript_CST_Types.TokUpperName.create))(parseProper);

746+ var parseOperator = map(function (v) {

747+ return function (v1) {

748+ if (v1 instanceof Data_Maybe.Nothing) {

749+ if (v === "<-") {

750+ return new PureScript_CST_Types.TokLeftArrow(PureScript_CST_Types.ASCII.value);

751+ };

752+ if (v === "\u2190") {

753+ return new PureScript_CST_Types.TokLeftArrow(PureScript_CST_Types.Unicode.value);

754+ };

755+ if (v === "->") {

756+ return new PureScript_CST_Types.TokRightArrow(PureScript_CST_Types.ASCII.value);

757+ };

758+ if (v === "\u2192") {

759+ return new PureScript_CST_Types.TokRightArrow(PureScript_CST_Types.Unicode.value);

760+ };

761+ if (v === "=>") {

762+ return new PureScript_CST_Types.TokRightFatArrow(PureScript_CST_Types.ASCII.value);

763+ };

764+ if (v === "\u21d2") {

765+ return new PureScript_CST_Types.TokRightFatArrow(PureScript_CST_Types.Unicode.value);

766+ };

767+ if (v === "::") {

768+ return new PureScript_CST_Types.TokDoubleColon(PureScript_CST_Types.ASCII.value);

769+ };

770+ if (v === "\u2237") {

771+ return new PureScript_CST_Types.TokDoubleColon(PureScript_CST_Types.Unicode.value);

772+ };

773+ if (v === "\u2200") {

774+ return new PureScript_CST_Types.TokForall(PureScript_CST_Types.Unicode.value);

775+ };

776+ if (v === "=") {

777+ return PureScript_CST_Types.TokEquals.value;

778+ };

779+ if (v === ".") {

780+ return PureScript_CST_Types.TokDot.value;

781+ };

782+ if (v === "\\") {

783+ return PureScript_CST_Types.TokBackslash.value;

784+ };

785+ if (v === "|") {

786+ return PureScript_CST_Types.TokPipe.value;

787+ };

788+ if (v === "@") {

789+ return PureScript_CST_Types.TokAt.value;

790+ };

791+ if (v === "`") {

792+ return PureScript_CST_Types.TokTick.value;

793+ };

794+ return new PureScript_CST_Types.TokOperator(Data_Maybe.Nothing.value, v);

795+ };

796+ return new PureScript_CST_Types.TokOperator(v1, v);

797+ };

798+ })(parseSymbolIdent);

799+ var parseModuleNamePrefix = regex(PureScript_CST_Errors.LexExpected.create("module name"))("(?:(?:\\p{Lu}[\\p{L}0-9_']*)\\.)*");

800+ var parseIdent = regex(PureScript_CST_Errors.LexExpected.create("ident"))("[\\p{Ll}_][\\p{L}0-9_']*");

801+ var parseLower = map(function (v) {

802+ return function (v1) {

803+ if (v1 instanceof Data_Maybe.Nothing) {

804+ if (v === "forall") {

805+ return new PureScript_CST_Types.TokForall(PureScript_CST_Types.ASCII.value);

806+ };

807+ if (v === "_") {

808+ return PureScript_CST_Types.TokUnderscore.value;

809+ };

810+ return new PureScript_CST_Types.TokLowerName(Data_Maybe.Nothing.value, v);

811+ };

812+ return new PureScript_CST_Types.TokLowerName(v1, v);

813+ };

814+ })(parseIdent);

815+ var parseName = alt(parseLower)(alt(parseUpper)(alt(parseOperator)(parseSymbol)));

816+ var parseModuleName = apply(map(function (v) {

817+ return function (v1) {

818+ return v1(toModuleName(v));

819+ };

820+ })(parseModuleNamePrefix))(parseName);

821+ var parseExponentSign = alt(string(PureScript_CST_Errors.LexExpected.create("negative"))("-"))(string(PureScript_CST_Errors.LexExpected.create("positive"))("+"));

822+ var intPartRegex = regex(PureScript_CST_Errors.LexExpected.create("int part"))("(0|[1-9][0-9_]*)");

823+ var parseExponentPart = apply(map(function (v) {

824+ return function (v1) {

825+ return {

826+ sign: v,

827+ exponent: v1

828+ };

829+ };

830+ })(optional(parseExponentSign)))(intPartRegex);

831+ var hexIntRegex = regex(PureScript_CST_Errors.LexExpected.create("hex int"))("[a-fA-F0-9]+");

832+ var hexIntPrefix = string(PureScript_CST_Errors.LexExpected.create("hex int prefix"))("0x");

833+ var parseHexInt = bind1(applySecond(hexIntPrefix)(hexIntRegex))(function (raw) {

834+ var v = Data_Int.fromStringAs(Data_Int.hexadecimal)(raw);

835+ if (v instanceof Data_Maybe.Just) {

836+ return pure1(new PureScript_CST_Types.TokInt("0x" + raw, new PureScript_CST_Types.SmallInt(v.value0)));

837+ };

838+ if (v instanceof Data_Maybe.Nothing) {

839+ return pure1(new PureScript_CST_Types.TokInt("0x" + raw, new PureScript_CST_Types.BigHex(raw)));

840+ };

841+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 631, column 5 - line 635, column 49): " + [ v.constructor.name ]);

842+ });

843+ var hexEscapeRegex = regex(PureScript_CST_Errors.LexExpected.create("hex"))("[a-fA-F0-9]{1,6}");

844+ var parseHexEscape = function (dictIsChar) {

845+ var fromCharCode1 = fromCharCode(dictIsChar);

846+ return bind1(hexEscapeRegex)(function (esc) {

847+ var v = bindFlipped(fromCharCode1)(Data_Int.fromStringAs(Data_Int.hexadecimal)(esc));

848+ if (v instanceof Data_Maybe.Just) {

849+ return pure1({

850+ raw: "\\x" + esc,

851+ "char": v.value0

852+ });

853+ };

854+ if (v instanceof Data_Maybe.Nothing) {

855+ return fail(new PureScript_CST_Errors.LexCharEscapeOutOfRange(esc));

856+ };

857+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 579, column 5 - line 583, column 43): " + [ v.constructor.name ]);

858+ });

859+ };

860+ var fractionPartRegex = regex(PureScript_CST_Errors.LexExpected.create("fraction part"))("[0-9_]+");

861+ var charSingleQuote = $$char(PureScript_CST_Errors.LexExpected.create("single quote"))("'");

862+ var charQuote = $$char(PureScript_CST_Errors.LexExpected.create("quote"))("\"");

863+ var charQuestionMark = $$char(PureScript_CST_Errors.LexExpected.create("question mark"))("?");

864+ var parseHole = map(function (v) {

865+ return new PureScript_CST_Types.TokHole(v);

866+ })($$try(applySecond(charQuestionMark)(alt(parseIdent)(parseProper))));

867+ var charExponent = $$char(PureScript_CST_Errors.LexExpected.create("exponent"))("e");

868+ var parseNumberExponentPart = optional(applySecond(charExponent)(parseExponentPart));

869+ var charDot = $$char(PureScript_CST_Errors.LexExpected.create("dot"))(".");

870+ var parseNumberFractionPart = optional($$try(applySecond(charDot)(fractionPartRegex)));

871+ var parseNumber = bind1(intPartRegex)(function (intPart) {

872+ return bind1(parseNumberFractionPart)(function (fractionPart) {

873+ return bind1(parseNumberExponentPart)(function (exponentPart) {

874+ var $282 = Data_Maybe.isNothing(fractionPart) && Data_Maybe.isNothing(exponentPart);

875+ if ($282) {

876+ var intVal = stripUnderscores(intPart);

877+ var v = Data_Int.fromString(intVal);

878+ if (v instanceof Data_Maybe.Just) {

879+ return pure1(new PureScript_CST_Types.TokInt(intPart, new PureScript_CST_Types.SmallInt(v.value0)));

880+ };

881+ if (v instanceof Data_Maybe.Nothing) {

882+ return pure1(new PureScript_CST_Types.TokInt(intPart, new PureScript_CST_Types.BigInt(intVal)));

883+ };

884+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 643, column 7 - line 647, column 48): " + [ v.constructor.name ]);

885+ };

886+ var raw = intPart + (foldMap1(function (fr) {

887+ return "." + fr;

888+ })(fractionPart) + foldMap1(function (ex) {

889+ return "e" + (fold(ex.sign) + ex.exponent);

890+ })(exponentPart));

891+ var v = Data_Number.fromString(stripUnderscores(raw));

892+ if (v instanceof Data_Maybe.Just) {

893+ return pure1(new PureScript_CST_Types.TokNumber(raw, v.value0));

894+ };

895+ if (v instanceof Data_Maybe.Nothing) {

896+ return fail(new PureScript_CST_Errors.LexNumberOutOfRange(raw));

897+ };

898+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 654, column 7 - line 658, column 41): " + [ v.constructor.name ]);

899+ });

900+ });

901+ });

902+ var parseNumericLiteral = alt(parseHexInt)(parseNumber);

903+ var charBackslash = $$char(PureScript_CST_Errors.LexExpected.create("backslash"))("\\");

904+ var charAny = satisfy(PureScript_CST_Errors.LexExpected.create("char"))(Data_Function["const"](true));

905+ var parseEscape = function (dictIsChar) {

906+ var fromChar1 = fromChar(dictIsChar);

907+ var parseHexEscape1 = parseHexEscape(dictIsChar);

908+ return bind1(charAny)(function (ch) {

909+ if (ch === "t") {

910+ return pure1({

911+ raw: "\\t",

912+ "char": fromChar1("\x09")

913+ });

914+ };

915+ if (ch === "r") {

916+ return pure1({

917+ raw: "\\r",

918+ "char": fromChar1("\x0d")

919+ });

920+ };

921+ if (ch === "n") {

922+ return pure1({

923+ raw: "\\n",

924+ "char": fromChar1("\x0a")

925+ });

926+ };

927+ if (ch === "\"") {

928+ return pure1({

929+ raw: "\\\"",

930+ "char": fromChar1("\"")

931+ });

932+ };

933+ if (ch === "'") {

934+ return pure1({

935+ raw: "\\'",

936+ "char": fromChar1("'")

937+ });

938+ };

939+ if (ch === "\\") {

940+ return pure1({

941+ raw: "\\\\",

942+ "char": fromChar1("\\")

943+ });

944+ };

945+ if (ch === "x") {

946+ return parseHexEscape1;

947+ };

948+ return fail(new PureScript_CST_Errors.LexInvalidCharEscape(Data_String_CodeUnits.singleton(ch)));

949+ });

950+ };

951+ var parseEscape1 = parseEscape(isCharChar);

952+ var parseChar = bind1(charAny)(function (ch) {

953+ if (ch === "\\") {

954+ return parseEscape1;

955+ };

956+ if (ch === "'") {

957+ return fail(new PureScript_CST_Errors.LexExpected("character", "empty character literal"));

958+ };

959+ return pure1({

960+ raw: Data_String_CodeUnits.singleton(ch),

961+ "char": ch

962+ });

963+ });

964+ var parseCharLiteral = map(function (v) {

965+ return new PureScript_CST_Types.TokChar(v.raw, v["char"]);

966+ })(applyFirst(applySecond(charSingleQuote)(parseChar))(charSingleQuote));

967+ var parseStringEscape = map(function (v) {

968+ return {

969+ raw: v.raw,

970+ string: Data_String_CodePoints.singleton(v["char"])

971+ };

972+ })(applySecond(charBackslash)(parseEscape(isCharCodePoint)));

973+ var parseStringPart = alt(parseStringChars)(alt(parseStringSpaceEscape)(parseStringEscape));

974+ var parseString = map(function (v) {

975+ var v1 = fold1(v);

976+ return new PureScript_CST_Types.TokString(v1.raw, v1.string);

977+ })(applyFirst(applySecond(charQuote)(many(parseStringPart)))(charQuote));

978+ var parseStringLiteral = alt(parseRawString)(parseString);

979+ return alt(parseHole)(alt(parseModuleName)(alt(parseCharLiteral)(alt(parseStringLiteral)(alt(parseNumericLiteral)(alt(tokenLeftParen)(alt(tokenRightParen)(alt(tokenLeftBrace)(alt(tokenRightBrace)(alt(tokenLeftSquare)(alt(tokenRightSquare)(alt(tokenTick)(tokenComma))))))))))));

980+})();

981+var lexToken = function ($328) {

982+ return (function (v) {

983+ if (v instanceof LexSucc && v.value1 === "") {

984+ return new Data_Either.Right(v.value0);

985+ };

986+ if (v instanceof LexSucc) {

987+ return new Data_Either.Left(function (v1) {

988+ return new PureScript_CST_Errors.ExpectedEof(v.value0);

989+ });

990+ };

991+ if (v instanceof LexFail) {

992+ return new Data_Either.Left(v.value0);

993+ };

994+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 257, column 18 - line 260, column 28): " + [ v.constructor.name ]);

995+ })(token($328));

996+};

997+var trailingComments = /* #__PURE__ */ (function () {

998+ return many(alt(map(PureScript_CST_Types.Comment.create)(comment))(map(PureScript_CST_Types.Space.create)(spaceComment)));

999+})();

1000+var lexWithState$prime = function (lexLeadingComments) {

1001+ var token$prime = apply(apply(map(function (v) {

1002+ return function (v1) {

1003+ return function (v2) {

1004+ return {

1005+ token: v,

1006+ trailing: v1,

1007+ nextLeading: v2

1008+ };

1009+ };

1010+ };

1011+ })(token))(trailingComments))(leadingComments);

1012+ var go = function (stack) {

1013+ return function (startPos) {

1014+ return function (leading) {

1015+ return function (str) {

1016+ return Data_Lazy.defer(function (v) {

1017+ var $303 = str === "";

1018+ if ($303) {

1019+ return PureScript_CST_TokenStream.step(PureScript_CST_TokenStream.unwindLayout(startPos)(Data_Lazy.defer(function (v1) {

1020+ return new PureScript_CST_TokenStream.TokenEOF(startPos, leading);

1021+ }))(stack));

1022+ };

1023+ var v1 = token$prime(str);

1024+ if (v1 instanceof LexFail) {

1025+ var errPos = bumpText(startPos)(0)(Data_String_CodeUnits.take(Data_String_CodeUnits.length(str) - Data_String_CodeUnits.length(v1.value1) | 0)(str));

1026+ return new PureScript_CST_TokenStream.TokenError(errPos, v1.value0(Data_Unit.unit), Data_Maybe.Nothing.value, stack);

1027+ };

1028+ if (v1 instanceof LexSucc) {

1029+ var endPos = bumpToken(startPos)(v1.value0.token);

1030+ var nextStart = foldl(bumpComment)(foldl(bumpComment)(endPos)(v1.value0.trailing))(v1.value0.nextLeading);

1031+ var posToken = {

1032+ range: {

1033+ start: startPos,

1034+ end: endPos

1035+ },

1036+ leadingComments: leading,

1037+ trailingComments: v1.value0.trailing,

1038+ value: v1.value0.token

1039+ };

1040+ var v2 = PureScript_CST_Layout.insertLayout(posToken)(nextStart)(stack);

1041+ return PureScript_CST_TokenStream.step(Data_Tuple.snd(consTokens(v2.value1)(new Data_Tuple.Tuple(nextStart, go(v2.value0)(nextStart)(v1.value0.nextLeading)(v1.value1)))));

1042+ };

1043+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 228, column 7 - line 247, column 63): " + [ v1.constructor.name ]);

1044+ });

1045+ };

1046+ };

1047+ };

1048+ };

1049+ var init = function (initStack) {

1050+ return function (initPos) {

1051+ return function (str) {

1052+ return Data_Lazy.defer(function (v) {

1053+ var v1 = lexLeadingComments(str);

1054+ if (v1 instanceof LexFail) {

1055+ return Partial_Unsafe.unsafeCrashWith("Leading comments can't fail.");

1056+ };

1057+ if (v1 instanceof LexSucc) {

1058+ var nextPos = foldl(bumpComment)(initPos)(v1.value0);

1059+ return PureScript_CST_TokenStream.step(go(initStack)(nextPos)(v1.value0)(v1.value1));

1060+ };

1061+ throw new Error("Failed pattern match at PureScript.CST.Lexer (line 215, column 5 - line 220, column 51): " + [ v1.constructor.name ]);

1062+ });

1063+ };

1064+ };

1065+ };

1066+ return init;

1067+};

1068+var lexModule = /* #__PURE__ */ (function () {

1069+ return lexWithState$prime(leadingModuleComments)(new Data_List_Types.Cons(new Data_Tuple.Tuple({

1070+ line: 0,

1071+ column: 0

1072+ }, PureScript_CST_Layout.LytRoot.value), Data_List_Types.Nil.value))({

1073+ line: 0,

1074+ column: 0

1075+ });

1076+})();

1077+var lexWithState = /* #__PURE__ */ lexWithState$prime(leadingComments);

1078+var lex = /* #__PURE__ */ (function () {

1079+ return lexWithState(new Data_List_Types.Cons(new Data_Tuple.Tuple({

1080+ line: 0,

1081+ column: 0

1082+ }, PureScript_CST_Layout.LytRoot.value), Data_List_Types.Nil.value))({

1083+ line: 0,

1084+ column: 0

1085+ });

1086+})();

1087+export {

1088+ lex,

1089+ lexModule,

1090+ lexWithState,

1091+ lexToken

1092+};

output-compile-fail/PureScript.CST.ModuleGraph/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.ModuleGraph/index.jsnew file+231

@@ -0,0 +1,231 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Bind from "../Control.Bind/index.js";

3+import * as Data_Array from "../Data.Array/index.js";

4+import * as Data_Either from "../Data.Either/index.js";

5+import * as Data_Eq from "../Data.Eq/index.js";

6+import * as Data_Foldable from "../Data.Foldable/index.js";

7+import * as Data_Function from "../Data.Function/index.js";

8+import * as Data_Functor from "../Data.Functor/index.js";

9+import * as Data_HeytingAlgebra from "../Data.HeytingAlgebra/index.js";

10+import * as Data_List from "../Data.List/index.js";

11+import * as Data_List_Types from "../Data.List.Types/index.js";

12+import * as Data_Map from "../Data.Map/index.js";

13+import * as Data_Map_Internal from "../Data.Map.Internal/index.js";

14+import * as Data_Maybe from "../Data.Maybe/index.js";

15+import * as Data_Semigroup from "../Data.Semigroup/index.js";

16+import * as Data_Semiring from "../Data.Semiring/index.js";

17+import * as Data_Set from "../Data.Set/index.js";

18+import * as Data_Tuple from "../Data.Tuple/index.js";

19+import * as Data_Unfoldable from "../Data.Unfoldable/index.js";

20+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

21+var eq = /* #__PURE__ */ Data_Eq.eq(Data_Eq.eqInt);

22+var add = /* #__PURE__ */ Data_Semiring.add(Data_Semiring.semiringInt);

23+var bind = /* #__PURE__ */ Control_Bind.bind(Control_Bind.bindArray);

24+var toUnfoldable = /* #__PURE__ */ Data_Map_Internal.toUnfoldable(Data_Unfoldable.unfoldableArray);

25+var append = /* #__PURE__ */ Data_Semigroup.append(Data_Semigroup.semigroupArray);

26+var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorArray);

27+var toUnfoldable1 = /* #__PURE__ */ Data_Set.toUnfoldable(Data_Unfoldable.unfoldableArray);

28+var bind1 = /* #__PURE__ */ Control_Bind.bind(Data_Maybe.bindMaybe);

29+var foldl = /* #__PURE__ */ Data_Foldable.foldl(Data_Set.foldableSet);

30+var all = /* #__PURE__ */ Data_Foldable.all(Data_Map_Internal.foldableMap)(Data_HeytingAlgebra.heytingAlgebraBoolean);

31+var map1 = /* #__PURE__ */ Data_Functor.map(Data_Either.functorEither);

32+var fromFoldable = /* #__PURE__ */ Data_Set.fromFoldable(Data_Foldable.foldableArray)(PureScript_CST_Types.ordModuleName);

33+var fromFoldable1 = /* #__PURE__ */ Data_Map_Internal.fromFoldable(PureScript_CST_Types.ordModuleName)(Data_Foldable.foldableArray);

34+var lookup = /* #__PURE__ */ Data_Map_Internal.lookup(PureScript_CST_Types.ordModuleName);

35+var toUnfoldable2 = /* #__PURE__ */ Data_List.toUnfoldable(Data_Unfoldable.unfoldableArray);

36+var Sorted = /* #__PURE__ */ (function () {

37+ function Sorted(value0) {

38+ this.value0 = value0;

39+ };

40+ Sorted.create = function (value0) {

41+ return new Sorted(value0);

42+ };

43+ return Sorted;

44+})();

45+var CycleDetected = /* #__PURE__ */ (function () {

46+ function CycleDetected(value0) {

47+ this.value0 = value0;

48+ };

49+ CycleDetected.create = function (value0) {

50+ return new CycleDetected(value0);

51+ };

52+ return CycleDetected;

53+})();

54+var topoSort = function (dictOrd) {

55+ var fromFoldableWith = Data_Map_Internal.fromFoldableWith(dictOrd)(Data_Foldable.foldableArray);

56+ var filterWithKey = Data_Map_Internal.filterWithKey(dictOrd);

57+ var member = Data_Set.member(dictOrd);

58+ var lookup1 = Data_Map_Internal.lookup(dictOrd);

59+ var insert = Data_Set.insert(dictOrd);

60+ var insertWith = Data_Map_Internal.insertWith(dictOrd);

61+ var $$delete = Data_Set["delete"](dictOrd);

62+ return function (graph) {

63+ var isRoot = function (v) {

64+ var $44 = v.value1 === 0;

65+ if ($44) {

66+ return new Data_Maybe.Just(v.value0);

67+ };

68+ return Data_Maybe.Nothing.value;

69+ };

70+ var importCounts = fromFoldableWith(add)(bind(toUnfoldable(graph))(function (v) {

71+ return append([ new Data_Tuple.Tuple(v.value0, 0) ])(map(Data_Function.flip(Data_Tuple.Tuple.create)(1))(toUnfoldable1(v.value1)));

72+ }));

73+ var startingModules = Data_Map.keys(filterWithKey(function (k) {

74+ return function (v) {

75+ return Data_Maybe.isJust(isRoot(new Data_Tuple.Tuple(k, v)));

76+ };

77+ })(importCounts));

78+ var depthFirst = function (v) {

79+ var $51 = member(v.curr)(v.visited);

80+ if ($51) {

81+ return new Data_Maybe.Just(new Data_List_Types.Cons(v.curr, v.path));

82+ };

83+ var $52 = Data_Maybe.maybe(true)(Data_Set.isEmpty)(lookup1(v.curr)(graph));

84+ if ($52) {

85+ return Data_Maybe.Nothing.value;

86+ };

87+ return bind1(lookup1(v.curr)(graph))(function (reachable) {

88+ return foldl(function (b) {

89+ return function (a) {

90+ var $53 = Data_Maybe.isJust(b);

91+ if ($53) {

92+ return b;

93+ };

94+ return depthFirst({

95+ path: new Data_List_Types.Cons(v.curr, v.path),

96+ visited: insert(v.curr)(v.visited),

97+ curr: a

98+ });

99+ };

100+ })(Data_Maybe.Nothing.value)(reachable);

101+ });

102+ };

103+ var decrementImport = function (usages) {

104+ return function (k) {

105+ return insertWith(add)(k)(-1 | 0)(usages);

106+ };

107+ };

108+ var appendRoots = function (usages) {

109+ return function (roots) {

110+ return function (curr) {

111+ return Data_Maybe.maybe(roots)(Data_Function.flip(insert)(roots))(bind1(lookup1(curr)(usages))(function (count) {

112+ return isRoot(new Data_Tuple.Tuple(curr, count));

113+ }));

114+ };

115+ };

116+ };

117+ var go = function ($copy_v) {

118+ var $tco_done = false;

119+ var $tco_result;

120+ function $tco_loop(v) {

121+ var v1 = Data_Set.findMin(v.roots);

122+ if (v1 instanceof Data_Maybe.Nothing) {

123+ var $59 = all(eq(0))(v.usages);

124+ if ($59) {

125+ $tco_done = true;

126+ return new Data_Either.Right({

127+ roots: v.roots,

128+ sorted: v.sorted,

129+ usages: v.usages

130+ });

131+ };

132+ var nonLeaf = Data_Map.keys(filterWithKey(function (a) {

133+ return function (count) {

134+ return count > 0 && !Data_Maybe.maybe(true)(Data_Set.isEmpty)(lookup1(a)(graph));

135+ };

136+ })(v.usages));

137+ var detectCycles = foldl(function (b) {

138+ return function (a) {

139+ var $60 = Data_Maybe.isJust(b);

140+ if ($60) {

141+ return b;

142+ };

143+ return depthFirst({

144+ path: Data_List_Types.Nil.value,

145+ visited: Data_Set.empty,

146+ curr: a

147+ });

148+ };

149+ })(Data_Maybe.Nothing.value)(nonLeaf);

150+ if (detectCycles instanceof Data_Maybe.Just) {

151+ $tco_done = true;

152+ return new Data_Either.Left(detectCycles.value0);

153+ };

154+ if (detectCycles instanceof Data_Maybe.Nothing) {

155+ $tco_done = true;

156+ return new Data_Either.Left(Data_List_Types.Nil.value);

157+ };

158+ throw new Error("Failed pattern match at PureScript.CST.ModuleGraph (line 79, column 9 - line 81, column 30): " + [ detectCycles.constructor.name ]);

159+ };

160+ if (v1 instanceof Data_Maybe.Just) {

161+ var reachable = Data_Maybe.fromMaybe(Data_Set.empty)(lookup1(v1.value0)(graph));

162+ var usages$prime = foldl(decrementImport)(v.usages)(reachable);

163+ $copy_v = {

164+ roots: foldl(appendRoots(usages$prime))($$delete(v1.value0)(v.roots))(reachable),

165+ sorted: new Data_List_Types.Cons(v1.value0, v.sorted),

166+ usages: usages$prime

167+ };

168+ return;

169+ };

170+ throw new Error("Failed pattern match at PureScript.CST.ModuleGraph (line 66, column 34 - line 91, column 10): " + [ v1.constructor.name ]);

171+ };

172+ while (!$tco_done) {

173+ $tco_result = $tco_loop($copy_v);

174+ };

175+ return $tco_result;

176+ };

177+ return map1(function (v) {

178+ return v.sorted;

179+ })(go({

180+ roots: startingModules,

181+ sorted: Data_List_Types.Nil.value,

182+ usages: importCounts

183+ }));

184+ };

185+};

186+var topoSort1 = /* #__PURE__ */ topoSort(PureScript_CST_Types.ordModuleName);

187+var moduleGraph = function (k) {

188+ var getImportName = function (v) {

189+ return v.module.name;

190+ };

191+ var go = function (v) {

192+ return new Data_Tuple.Tuple(v.name.name, fromFoldable(map(getImportName)(v.imports)));

193+ };

194+ var $80 = map(function ($82) {

195+ return go(k($82));

196+ });

197+ return function ($81) {

198+ return fromFoldable1($80($81));

199+ };

200+};

201+var sortModules = function (k) {

202+ return function (moduleHeaders) {

203+ var graph = moduleGraph(k)(moduleHeaders);

204+ var getModuleName = function (v) {

205+ return v.name.name;

206+ };

207+ var knownModuleHeaders = fromFoldable1(map(function (a) {

208+ return new Data_Tuple.Tuple(getModuleName(k(a)), a);

209+ })(moduleHeaders));

210+ var lookupModuleHeaders = (function () {

211+ var $83 = Data_Array.mapMaybe(Data_Function.flip(lookup)(knownModuleHeaders));

212+ return function ($84) {

213+ return $83(toUnfoldable2($84));

214+ };

215+ })();

216+ var v = topoSort1(graph);

217+ if (v instanceof Data_Either.Left) {

218+ return new CycleDetected(lookupModuleHeaders(v.value0));

219+ };

220+ if (v instanceof Data_Either.Right) {

221+ return new Sorted(lookupModuleHeaders(v.value0));

222+ };

223+ throw new Error("Failed pattern match at PureScript.CST.ModuleGraph (line 51, column 3 - line 53, column 56): " + [ v.constructor.name ]);

224+ };

225+};

226+export {

227+ moduleGraph,

228+ sortModules,

229+ Sorted,

230+ CycleDetected

231+};

output-compile-fail/PureScript.CST.Parser.Monad/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Parser.Monad/index.jsnew file+392

@@ -0,0 +1,392 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Alt from "../Control.Alt/index.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Data_Array from "../Data.Array/index.js";

5+import * as Data_Either from "../Data.Either/index.js";

6+import * as Data_Functor from "../Data.Functor/index.js";

7+import * as Data_Lazy from "../Data.Lazy/index.js";

8+import * as Data_List from "../Data.List/index.js";

9+import * as Data_List_Types from "../Data.List.Types/index.js";

10+import * as Data_Maybe from "../Data.Maybe/index.js";

11+import * as Data_Tuple from "../Data.Tuple/index.js";

12+import * as Data_Unfoldable from "../Data.Unfoldable/index.js";

13+import * as Data_Unit from "../Data.Unit/index.js";

14+import * as PureScript_CST_Errors from "../PureScript.CST.Errors/index.js";

15+import * as PureScript_CST_TokenStream from "../PureScript.CST.TokenStream/index.js";

16+var $runtime_lazy = function (name, moduleName, init) {

17+ var state = 0;

18+ var val;

19+ return function (lineNumber) {

20+ if (state === 2) return val;

21+ if (state === 1) throw new ReferenceError(name + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);

22+ state = 1;

23+ val = init();

24+ state = 2;

25+ return val;

26+ };

27+};

28+var toUnfoldable = /* #__PURE__ */ Data_List.toUnfoldable(Data_Unfoldable.unfoldableArray);

29+var More = /* #__PURE__ */ (function () {

30+ function More(value0) {

31+ this.value0 = value0;

32+ };

33+ More.create = function (value0) {

34+ return new More(value0);

35+ };

36+ return More;

37+})();

38+var Done = /* #__PURE__ */ (function () {

39+ function Done(value0) {

40+ this.value0 = value0;

41+ };

42+ Done.create = function (value0) {

43+ return new Done(value0);

44+ };

45+ return Done;

46+})();

47+var ParseFail = /* #__PURE__ */ (function () {

48+ function ParseFail(value0, value1) {

49+ this.value0 = value0;

50+ this.value1 = value1;

51+ };

52+ ParseFail.create = function (value0) {

53+ return function (value1) {

54+ return new ParseFail(value0, value1);

55+ };

56+ };

57+ return ParseFail;

58+})();

59+var ParseSucc = /* #__PURE__ */ (function () {

60+ function ParseSucc(value0, value1) {

61+ this.value0 = value0;

62+ this.value1 = value1;

63+ };

64+ ParseSucc.create = function (value0) {

65+ return function (value1) {

66+ return new ParseSucc(value0, value1);

67+ };

68+ };

69+ return ParseSucc;

70+})();

71+var Parser = function (x) {

72+ return x;

73+};

74+var lazyParser = {

75+ defer: function (k) {

76+ var parser = Data_Lazy.defer(k);

77+ return function (state, more, resume, done) {

78+ var v = Data_Lazy.force(parser);

79+ return v(state, more, resume, done);

80+ };

81+ }

82+};

83+var functorParser = {

84+ map: function (f) {

85+ return function (v) {

86+ return function (state1, more, resume, done) {

87+ return v(state1, more, resume, function (state2, a) {

88+ return done(state2, f(a));

89+ });

90+ };

91+ };

92+ }

93+};

94+var map = /* #__PURE__ */ Data_Functor.map(functorParser);

95+var applyParser = {

96+ apply: function (v) {

97+ return function (v1) {

98+ return function (state1, more, resume, done) {

99+ return v(state1, more, resume, function (state2, f) {

100+ return more(function (v2) {

101+ return v1(state2, more, resume, function (state3, a) {

102+ return done(state3, f(a));

103+ });

104+ });

105+ });

106+ };

107+ };

108+ },

109+ Functor0: function () {

110+ return functorParser;

111+ }

112+};

113+var bindParser = {

114+ bind: function (v) {

115+ return function (k) {

116+ return function (state1, more, resume, done) {

117+ return v(state1, more, resume, function (state2, a) {

118+ return more(function (v1) {

119+ var v2 = k(a);

120+ return v2(state2, more, resume, done);

121+ });

122+ });

123+ };

124+ };

125+ },

126+ Apply0: function () {

127+ return applyParser;

128+ }

129+};

130+var applicativeParser = {

131+ pure: function (a) {

132+ return function (state1, v, v1, done) {

133+ return done(state1, a);

134+ };

135+ },

136+ Apply0: function () {

137+ return applyParser;

138+ }

139+};

140+var pure = /* #__PURE__ */ Control_Applicative.pure(applicativeParser);

141+var monadParser = {

142+ Applicative0: function () {

143+ return applicativeParser;

144+ },

145+ Bind1: function () {

146+ return bindParser;

147+ }

148+};

149+var altParser = {

150+ alt: function (v) {

151+ return function (v1) {

152+ return function (state1, more, resume, done) {

153+ var state2 = (function () {

154+ if (state1.consumed) {

155+ return {

156+ errors: state1.errors,

157+ stream: state1.stream,

158+ consumed: false

159+ };

160+ };

161+ return state1;

162+ })();

163+ return v(state2, more, function (state3, error) {

164+ if (state3.consumed) {

165+ return resume(state3, error);

166+ };

167+ return v1(state1, more, resume, done);

168+ }, done);

169+ };

170+ };

171+ },

172+ Functor0: function () {

173+ return functorParser;

174+ }

175+};

176+var alt = /* #__PURE__ */ Control_Alt.alt(altParser);

177+var $$try = function (v) {

178+ return function (state1, more, resume, done) {

179+ return v(state1, more, function (state2, error) {

180+ return resume({

181+ errors: state2.errors,

182+ stream: state2.stream,

183+ consumed: state1.consumed

184+ }, error);

185+ }, done);

186+ };

187+};

188+var take = function (k) {

189+ return function (state, v, resume, done) {

190+ var v1 = PureScript_CST_TokenStream.step(state.stream);

191+ if (v1 instanceof PureScript_CST_TokenStream.TokenError) {

192+ return resume(state, {

193+ error: v1.value1,

194+ position: v1.value0

195+ });

196+ };

197+ if (v1 instanceof PureScript_CST_TokenStream.TokenEOF) {

198+ return resume(state, {

199+ error: PureScript_CST_Errors.UnexpectedEof.value,

200+ position: v1.value0

201+ });

202+ };

203+ if (v1 instanceof PureScript_CST_TokenStream.TokenCons) {

204+ var v2 = k(v1.value0);

205+ if (v2 instanceof Data_Either.Left) {

206+ return resume(state, {

207+ error: v2.value0,

208+ position: v1.value0.range.start

209+ });

210+ };

211+ if (v2 instanceof Data_Either.Right) {

212+ return done({

213+ errors: state.errors,

214+ consumed: true,

215+ stream: v1.value2

216+ }, v2.value0);

217+ };

218+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 172, column 11 - line 182, column 18): " + [ v2.constructor.name ]);

219+ };

220+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 166, column 7 - line 182, column 18): " + [ v1.constructor.name ]);

221+ };

222+};

223+var runParser$prime = function (state1) {

224+ return function (v) {

225+ var run = function ($copy_v1) {

226+ var $tco_done = false;

227+ var $tco_result;

228+ function $tco_loop(v1) {

229+ if (v1 instanceof More) {

230+ $copy_v1 = v1.value0(Data_Unit.unit);

231+ return;

232+ };

233+ if (v1 instanceof Done) {

234+ $tco_done = true;

235+ return v1.value0;

236+ };

237+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 241, column 9 - line 243, column 16): " + [ v1.constructor.name ]);

238+ };

239+ while (!$tco_done) {

240+ $tco_result = $tco_loop($copy_v1);

241+ };

242+ return $tco_result;

243+ };

244+ return run(v(state1, More.create, function (state2, error) {

245+ return new Done(new ParseFail(error, state2));

246+ }, function (state2, value) {

247+ return new Done(new ParseSucc(value, state2));

248+ }));

249+ };

250+};

251+var recover = function (k) {

252+ return function (v) {

253+ return function (state1, more, resume, done) {

254+ return v({

255+ errors: state1.errors,

256+ stream: state1.stream,

257+ consumed: false

258+ }, more, function (state2, error) {

259+ var v1 = k(error)(state1.stream);

260+ if (v1 instanceof Data_Maybe.Nothing) {

261+ return resume({

262+ errors: state2.errors,

263+ stream: state2.stream,

264+ consumed: state1.consumed

265+ }, error);

266+ };

267+ if (v1 instanceof Data_Maybe.Just) {

268+ return done({

269+ consumed: true,

270+ errors: Data_Array.snoc(state2.errors)(error),

271+ stream: v1.value0.value1

272+ }, v1.value0.value0);

273+ };

274+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 149, column 13 - line 158, column 20): " + [ v1.constructor.name ]);

275+ }, done);

276+ };

277+ };

278+};

279+var optional = function (p) {

280+ return alt(map(Data_Maybe.Just.create)(p))(pure(Data_Maybe.Nothing.value));

281+};

282+var many = function (v) {

283+ return function (state1, more, resume, done) {

284+ var $lazy_go = $runtime_lazy("go", "PureScript.CST.Parser.Monad", function () {

285+ return function (acc, state2) {

286+ var state2$prime = (function () {

287+ if (state2.consumed) {

288+ return {

289+ errors: state2.errors,

290+ stream: state2.stream,

291+ consumed: false

292+ };

293+ };

294+ return state2;

295+ })();

296+ return v(state2$prime, more, function (state3, error) {

297+ if (state3.consumed) {

298+ return resume(state3, error);

299+ };

300+ return done(state2, Data_Array.reverse(toUnfoldable(acc)));

301+ }, function (state3, value) {

302+ return $lazy_go(225)(new Data_List_Types.Cons(value, acc), state3);

303+ });

304+ };

305+ });

306+ var go = $lazy_go(212);

307+ return go(Data_List_Types.Nil.value, state1);

308+ };

309+};

310+var lookAhead = function (v) {

311+ return function (state1, more, resume, done) {

312+ return v(state1, more, function (v1, error) {

313+ return resume(state1, error);

314+ }, function (v1, value) {

315+ return done(state1, value);

316+ });

317+ };

318+};

319+var initialParserState = function (stream) {

320+ return {

321+ consumed: false,

322+ errors: [ ],

323+ stream: stream

324+ };

325+};

326+var fromParserResult = function (v) {

327+ if (v instanceof ParseFail) {

328+ return new Data_Either.Left(v.value0);

329+ };

330+ if (v instanceof ParseSucc) {

331+ return new Data_Either.Right(new Data_Tuple.Tuple(v.value0, v.value1.errors));

332+ };

333+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 253, column 20 - line 257, column 29): " + [ v.constructor.name ]);

334+};

335+var runParser = function (stream) {

336+ var $109 = runParser$prime(initialParserState(stream));

337+ return function ($110) {

338+ return fromParserResult($109($110));

339+ };

340+};

341+var fail = function (error) {

342+ return function (state, v, resume, v1) {

343+ return resume(state, error);

344+ };

345+};

346+var eof = function (state, v, resume, done) {

347+ var v1 = PureScript_CST_TokenStream.step(state.stream);

348+ if (v1 instanceof PureScript_CST_TokenStream.TokenError) {

349+ return resume(state, {

350+ error: v1.value1,

351+ position: v1.value0

352+ });

353+ };

354+ if (v1 instanceof PureScript_CST_TokenStream.TokenEOF) {

355+ return done({

356+ stream: state.stream,

357+ errors: state.errors,

358+ consumed: true

359+ }, new Data_Tuple.Tuple(v1.value0, v1.value1));

360+ };

361+ if (v1 instanceof PureScript_CST_TokenStream.TokenCons) {

362+ return resume(state, {

363+ error: new PureScript_CST_Errors.ExpectedEof(v1.value0.value),

364+ position: v1.value0.range.start

365+ });

366+ };

367+ throw new Error("Failed pattern match at PureScript.CST.Parser.Monad (line 188, column 7 - line 197, column 14): " + [ v1.constructor.name ]);

368+};

369+export {

370+ Parser,

371+ ParseFail,

372+ ParseSucc,

373+ initialParserState,

374+ fromParserResult,

375+ runParser,

376+ runParser$prime,

377+ take,

378+ fail,

379+ $$try as try,

380+ lookAhead,

381+ many,

382+ optional,

383+ eof,

384+ recover,

385+ functorParser,

386+ applyParser,

387+ applicativeParser,

388+ bindParser,

389+ monadParser,

390+ altParser,

391+ lazyParser

392+};

output-compile-fail/PureScript.CST.Parser/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Parser/index.jsnew file+1612

@@ -0,0 +1,1612 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Alt from "../Control.Alt/index.js";

3+import * as Control_Applicative from "../Control.Applicative/index.js";

4+import * as Control_Apply from "../Control.Apply/index.js";

5+import * as Control_Bind from "../Control.Bind/index.js";

6+import * as Control_Lazy from "../Control.Lazy/index.js";

7+import * as Data_Array from "../Data.Array/index.js";

8+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

9+import * as Data_Either from "../Data.Either/index.js";

10+import * as Data_Foldable from "../Data.Foldable/index.js";

11+import * as Data_Function from "../Data.Function/index.js";

12+import * as Data_Functor from "../Data.Functor/index.js";

13+import * as Data_Maybe from "../Data.Maybe/index.js";

14+import * as Data_Ord from "../Data.Ord/index.js";

15+import * as Data_Set from "../Data.Set/index.js";

16+import * as Data_Tuple from "../Data.Tuple/index.js";

17+import * as PureScript_CST_Errors from "../PureScript.CST.Errors/index.js";

18+import * as PureScript_CST_Layout from "../PureScript.CST.Layout/index.js";

19+import * as PureScript_CST_Parser_Monad from "../PureScript.CST.Parser.Monad/index.js";

20+import * as PureScript_CST_TokenStream from "../PureScript.CST.TokenStream/index.js";

21+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

22+var $runtime_lazy = function (name, moduleName, init) {

23+ var state = 0;

24+ var val;

25+ return function (lineNumber) {

26+ if (state === 2) return val;

27+ if (state === 1) throw new ReferenceError(name + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);

28+ state = 1;

29+ val = init();

30+ state = 2;

31+ return val;

32+ };

33+};

34+var bind = /* #__PURE__ */ Control_Bind.bind(PureScript_CST_Parser_Monad.bindParser);

35+var pure = /* #__PURE__ */ Control_Applicative.pure(PureScript_CST_Parser_Monad.applicativeParser);

36+var apply = /* #__PURE__ */ Control_Apply.apply(PureScript_CST_Parser_Monad.applyParser);

37+var map = /* #__PURE__ */ Data_Functor.map(PureScript_CST_Parser_Monad.functorParser);

38+var member = /* #__PURE__ */ Data_Set.member(Data_Ord.ordString);

39+var alt = /* #__PURE__ */ Control_Alt.alt(PureScript_CST_Parser_Monad.altParser);

40+var applyFirst = /* #__PURE__ */ Control_Apply.applyFirst(PureScript_CST_Parser_Monad.applyParser);

41+var applySecond = /* #__PURE__ */ Control_Apply.applySecond(PureScript_CST_Parser_Monad.applyParser);

42+var defer = /* #__PURE__ */ Control_Lazy.defer(PureScript_CST_Parser_Monad.lazyParser);

43+var voidRight = /* #__PURE__ */ Data_Functor.voidRight(PureScript_CST_Parser_Monad.functorParser);

44+var wrapped = function (openTok) {

45+ return function (closeTok) {

46+ return function (valueParser) {

47+ return bind(openTok)(function (open) {

48+ return bind(valueParser)(function (value) {

49+ return bind(closeTok)(function (close) {

50+ return pure({

51+ open: open,

52+ value: value,

53+ close: close

54+ });

55+ });

56+ });

57+ });

58+ };

59+ };

60+};

61+var separated = function (sepParser) {

62+ return function (valueParser) {

63+ return apply(map(function (v) {

64+ return function (v1) {

65+ return {

66+ head: v,

67+ tail: v1

68+ };

69+ };

70+ })(valueParser))(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(sepParser))(valueParser)));

71+ };

72+};

73+var reservedKeywords = /* #__PURE__ */ Data_Set.fromFoldable(Data_Foldable.foldableArray)(Data_Ord.ordString)([ "ado", "case", "class", "data", "derive", "do", "else", "false", "foreign", "if", "import", "in", "infix", "infixl", "infixr", "instance", "let", "module", "newtype", "of", "then", "true", "type", "where" ]);

74+var recoverTokensWhile = function (p) {

75+ return function (initStream) {

76+ var indent = Data_Maybe.maybe(0)(function (v) {

77+ return v.column;

78+ })(PureScript_CST_Layout.currentIndent(PureScript_CST_TokenStream.layoutStack(initStream)));

79+ var go = function ($copy_acc) {

80+ return function ($copy_stream) {

81+ var $tco_var_acc = $copy_acc;

82+ var $tco_done = false;

83+ var $tco_result;

84+ function $tco_loop(acc, stream) {

85+ var v = PureScript_CST_TokenStream.step(stream);

86+ if (v instanceof PureScript_CST_TokenStream.TokenError) {

87+ $tco_done = true;

88+ return new Data_Tuple.Tuple(acc, stream);

89+ };

90+ if (v instanceof PureScript_CST_TokenStream.TokenEOF) {

91+ $tco_done = true;

92+ return new Data_Tuple.Tuple(acc, stream);

93+ };

94+ if (v instanceof PureScript_CST_TokenStream.TokenCons) {

95+ var $135 = p(v.value0)(indent);

96+ if ($135) {

97+ $tco_var_acc = Data_Array.snoc(acc)(v.value0);

98+ $copy_stream = v.value2;

99+ return;

100+ };

101+ $tco_done = true;

102+ return new Data_Tuple.Tuple(acc, stream);

103+ };

104+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 1194, column 19 - line 1203, column 25): " + [ v.constructor.name ]);

105+ };

106+ while (!$tco_done) {

107+ $tco_result = $tco_loop($tco_var_acc, $copy_stream);

108+ };

109+ return $tco_result;

110+ };

111+ };

112+ return go([ ])(initStream);

113+ };

114+};

115+var recoverIndent = function (mkNode) {

116+ return PureScript_CST_Parser_Monad.recover(function (v) {

117+ return function (stream) {

118+ var v1 = recoverTokensWhile(function (tok) {

119+ return function (indent) {

120+ if (tok.value instanceof PureScript_CST_Types.TokLayoutEnd) {

121+ return tok.value.value0 > indent;

122+ };

123+ if (tok.value instanceof PureScript_CST_Types.TokLayoutSep) {

124+ return tok.value.value0 > indent;

125+ };

126+ return true;

127+ };

128+ })(stream);

129+ var $145 = Data_Array["null"](v1.value0);

130+ if ($145) {

131+ return Data_Maybe.Nothing.value;

132+ };

133+ return new Data_Maybe.Just(new Data_Tuple.Tuple(mkNode({

134+ position: v.position,

135+ error: v.error,

136+ tokens: v1.value0

137+ }), v1.value1));

138+ };

139+ });

140+};

141+var recoverLetBinding = /* #__PURE__ */ (function () {

142+ return recoverIndent(PureScript_CST_Types.LetBindingError.create);

143+})();

144+var recoverDoStatement = /* #__PURE__ */ (function () {

145+ return recoverIndent(PureScript_CST_Types.DoError.create);

146+})();

147+var recoverDecl = /* #__PURE__ */ (function () {

148+ return recoverIndent(PureScript_CST_Types.DeclError.create);

149+})();

150+var parseSmallInt = /* #__PURE__ */ PureScript_CST_Parser_Monad.take(function (v) {

151+ if (v.value instanceof PureScript_CST_Types.TokInt && v.value.value1 instanceof PureScript_CST_Types.SmallInt) {

152+ return new Data_Either.Right(new Data_Tuple.Tuple(v, v.value.value1.value0));

153+ };

154+ if (v.value instanceof PureScript_CST_Types.TokInt) {

155+ return new Data_Either.Left(new PureScript_CST_Errors.LexIntOutOfRange(v.value.value0));

156+ };

157+ return new Data_Either.Left(new PureScript_CST_Errors.UnexpectedToken(v.value));

158+});

159+var many1 = function (parser) {

160+ return apply(map(Data_Array_NonEmpty["cons$prime"])(parser))(PureScript_CST_Parser_Monad.many(parser));

161+};

162+var expectMap = function (k) {

163+ return PureScript_CST_Parser_Monad.take(function (tok) {

164+ var v = k(tok);

165+ if (v instanceof Data_Maybe.Just) {

166+ return new Data_Either.Right(v.value0);

167+ };

168+ if (v instanceof Data_Maybe.Nothing) {

169+ return new Data_Either.Left(new PureScript_CST_Errors.UnexpectedToken(tok.value));

170+ };

171+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 46, column 3 - line 50, column 39): " + [ v.constructor.name ]);

172+ });

173+};

174+var parseBoolean = /* #__PURE__ */ expectMap(function (v) {

175+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "true")) {

176+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, true));

177+ };

178+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && v.value.value1 === "false")) {

179+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, false));

180+ };

181+ return Data_Maybe.Nothing.value;

182+});

183+var parseChar = /* #__PURE__ */ expectMap(function (v) {

184+ if (v.value instanceof PureScript_CST_Types.TokChar) {

185+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, v.value.value1));

186+ };

187+ return Data_Maybe.Nothing.value;

188+});

189+var parseHole = /* #__PURE__ */ expectMap(function (v) {

190+ if (v.value instanceof PureScript_CST_Types.TokHole) {

191+ return new Data_Maybe.Just({

192+ token: v,

193+ name: v.value.value0

194+ });

195+ };

196+ return Data_Maybe.Nothing.value;

197+});

198+var parseIdent = /* #__PURE__ */ expectMap(function (v) {

199+ if (v.value instanceof PureScript_CST_Types.TokLowerName && (v.value.value0 instanceof Data_Maybe.Nothing && !member(v.value.value1)(reservedKeywords))) {

200+ return new Data_Maybe.Just({

201+ token: v,

202+ name: v.value.value1

203+ });

204+ };

205+ return Data_Maybe.Nothing.value;

206+});

207+var $$parseInt = /* #__PURE__ */ expectMap(function (v) {

208+ if (v.value instanceof PureScript_CST_Types.TokInt) {

209+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, v.value.value1));

210+ };

211+ return Data_Maybe.Nothing.value;

212+});

213+var parseLabel = /* #__PURE__ */ expectMap(function (v) {

214+ if (v.value instanceof PureScript_CST_Types.TokRawString) {

215+ return new Data_Maybe.Just({

216+ token: v,

217+ name: v.value.value0

218+ });

219+ };

220+ if (v.value instanceof PureScript_CST_Types.TokString) {

221+ return new Data_Maybe.Just({

222+ token: v,

223+ name: v.value.value1

224+ });

225+ };

226+ if (v.value instanceof PureScript_CST_Types.TokLowerName && v.value.value0 instanceof Data_Maybe.Nothing) {

227+ return new Data_Maybe.Just({

228+ token: v,

229+ name: v.value.value1

230+ });

231+ };

232+ return Data_Maybe.Nothing.value;

233+});

234+var parseModuleName = /* #__PURE__ */ expectMap(function (v) {

235+ if (v.value instanceof PureScript_CST_Types.TokUpperName && v.value.value0 instanceof Data_Maybe.Just) {

236+ return new Data_Maybe.Just({

237+ token: v,

238+ name: v.value.value0.value0 + ("." + v.value.value1)

239+ });

240+ };

241+ if (v.value instanceof PureScript_CST_Types.TokUpperName && v.value.value0 instanceof Data_Maybe.Nothing) {

242+ return new Data_Maybe.Just({

243+ token: v,

244+ name: v.value.value1

245+ });

246+ };

247+ return Data_Maybe.Nothing.value;

248+});

249+var parseNumber = /* #__PURE__ */ expectMap(function (v) {

250+ if (v.value instanceof PureScript_CST_Types.TokNumber) {

251+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, v.value.value1));

252+ };

253+ return Data_Maybe.Nothing.value;

254+});

255+var parseOperator = /* #__PURE__ */ expectMap(function (v) {

256+ if (v.value instanceof PureScript_CST_Types.TokOperator && v.value.value0 instanceof Data_Maybe.Nothing) {

257+ return new Data_Maybe.Just({

258+ token: v,

259+ name: v.value.value1

260+ });

261+ };

262+ return Data_Maybe.Nothing.value;

263+});

264+var parseProper = /* #__PURE__ */ expectMap(function (v) {

265+ if (v.value instanceof PureScript_CST_Types.TokUpperName && v.value.value0 instanceof Data_Maybe.Nothing) {

266+ return new Data_Maybe.Just({

267+ token: v,

268+ name: v.value.value1

269+ });

270+ };

271+ return Data_Maybe.Nothing.value;

272+});

273+var parseQualifiedIdent = /* #__PURE__ */ expectMap(function (v) {

274+ if (v.value instanceof PureScript_CST_Types.TokLowerName && !member(v.value.value1)(reservedKeywords)) {

275+ return new Data_Maybe.Just({

276+ token: v,

277+ module: v.value.value0,

278+ name: v.value.value1

279+ });

280+ };

281+ return Data_Maybe.Nothing.value;

282+});

283+var parseQualifiedIdentOrProper = /* #__PURE__ */ expectMap(function (v) {

284+ if (v.value instanceof PureScript_CST_Types.TokLowerName) {

285+ return new Data_Maybe.Just({

286+ token: v,

287+ module: v.value.value0,

288+ name: new Data_Either.Left(v.value.value1)

289+ });

290+ };

291+ if (v.value instanceof PureScript_CST_Types.TokUpperName) {

292+ return new Data_Maybe.Just({

293+ token: v,

294+ module: v.value.value0,

295+ name: new Data_Either.Right(v.value.value1)

296+ });

297+ };

298+ return Data_Maybe.Nothing.value;

299+});

300+var parseQualifiedOperator = /* #__PURE__ */ expectMap(function (v) {

301+ if (v.value instanceof PureScript_CST_Types.TokOperator) {

302+ return new Data_Maybe.Just({

303+ token: v,

304+ module: v.value.value0,

305+ name: v.value.value1

306+ });

307+ };

308+ return Data_Maybe.Nothing.value;

309+});

310+var parseQualifiedProper = /* #__PURE__ */ expectMap(function (v) {

311+ if (v.value instanceof PureScript_CST_Types.TokUpperName) {

312+ return new Data_Maybe.Just({

313+ token: v,

314+ module: v.value.value0,

315+ name: v.value.value1

316+ });

317+ };

318+ return Data_Maybe.Nothing.value;

319+});

320+var parseQualifiedSymbol = /* #__PURE__ */ expectMap(function (v) {

321+ if (v.value instanceof PureScript_CST_Types.TokSymbolName) {

322+ return new Data_Maybe.Just({

323+ token: v,

324+ module: v.value.value0,

325+ name: v.value.value1

326+ });

327+ };

328+ return Data_Maybe.Nothing.value;

329+});

330+var parseString = /* #__PURE__ */ expectMap(function (v) {

331+ if (v.value instanceof PureScript_CST_Types.TokString) {

332+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, v.value.value1));

333+ };

334+ if (v.value instanceof PureScript_CST_Types.TokRawString) {

335+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, v.value.value0));

336+ };

337+ return Data_Maybe.Nothing.value;

338+});

339+var parseSymbol = /* #__PURE__ */ expectMap(function (v) {

340+ if (v.value instanceof PureScript_CST_Types.TokSymbolName && v.value.value0 instanceof Data_Maybe.Nothing) {

341+ return new Data_Maybe.Just({

342+ token: v,

343+ name: v.value.value1

344+ });

345+ };

346+ return Data_Maybe.Nothing.value;

347+});

348+var expect = function (pred) {

349+ return expectMap(function (tok) {

350+ var $244 = pred(tok.value);

351+ if ($244) {

352+ return new Data_Maybe.Just(tok);

353+ };

354+ return Data_Maybe.Nothing.value;

355+ });

356+};

357+var tokAt = /* #__PURE__ */ expect(function (v) {

358+ if (v instanceof PureScript_CST_Types.TokAt) {

359+ return true;

360+ };

361+ return false;

362+});

363+var tokBackslash = /* #__PURE__ */ expect(function (v) {

364+ if (v instanceof PureScript_CST_Types.TokBackslash) {

365+ return true;

366+ };

367+ return false;

368+});

369+var tokComma = /* #__PURE__ */ expect(function (v) {

370+ if (v instanceof PureScript_CST_Types.TokComma) {

371+ return true;

372+ };

373+ return false;

374+});

375+var tokDot = /* #__PURE__ */ expect(function (v) {

376+ if (v instanceof PureScript_CST_Types.TokDot) {

377+ return true;

378+ };

379+ return false;

380+});

381+var parseRecordAccessor = function (expr) {

382+ return bind(tokDot)(function (dot) {

383+ return bind(separated(tokDot)(parseLabel))(function (path) {

384+ return pure(new PureScript_CST_Types.ExprRecordAccessor({

385+ expr: expr,

386+ dot: dot,

387+ path: path

388+ }));

389+ });

390+ });

391+};

392+var tokDoubleColon = /* #__PURE__ */ expect(function (v) {

393+ if (v instanceof PureScript_CST_Types.TokDoubleColon) {

394+ return true;

395+ };

396+ return false;

397+});

398+var parseInstanceName = /* #__PURE__ */ (function () {

399+ return apply(map(Data_Tuple.Tuple.create)(parseIdent))(tokDoubleColon);

400+})();

401+var tokEquals = /* #__PURE__ */ expect(function (v) {

402+ if (v instanceof PureScript_CST_Types.TokEquals) {

403+ return true;

404+ };

405+ return false;

406+});

407+var tokForall = /* #__PURE__ */ expect(function (v) {

408+ if (v instanceof PureScript_CST_Types.TokForall) {

409+ return true;

410+ };

411+ return false;

412+});

413+var tokKeyOperator = function (sym) {

414+ return expect(function (v) {

415+ if (v instanceof PureScript_CST_Types.TokOperator && v.value0 instanceof Data_Maybe.Nothing) {

416+ return sym === v.value1;

417+ };

418+ return false;

419+ });

420+};

421+var parseBinderNegative = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyOperator("-"))(function (negative) {

422+ return alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderInt.create(new Data_Maybe.Just(negative))))($$parseInt))(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderNumber.create(new Data_Maybe.Just(negative))))(parseNumber));

423+});

424+var parseRecordLabeled = function (valueParser) {

425+ var parseRecordField = apply(map(Data_Tuple.uncurry(PureScript_CST_Types.RecordField.create))(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseLabel))(tokKeyOperator(":")))))(valueParser);

426+ return alt(parseRecordField)(map(PureScript_CST_Types.RecordPun.create)(parseIdent));

427+};

428+var parseTypeNegative = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyOperator("-"))(function (negative) {

429+ return map(Data_Tuple.uncurry(PureScript_CST_Types.TypeInt.create(new Data_Maybe.Just(negative))))($$parseInt);

430+});

431+var tokKeySymbol = function (sym) {

432+ return expect(function (v) {

433+ if (v instanceof PureScript_CST_Types.TokSymbolName && v.value0 instanceof Data_Maybe.Nothing) {

434+ return sym === v.value1;

435+ };

436+ return false;

437+ });

438+};

439+var tokKeyword = function (kw) {

440+ return expect(function (v) {

441+ if (v instanceof PureScript_CST_Types.TokLowerName && v.value0 instanceof Data_Maybe.Nothing) {

442+ return kw === v.value1;

443+ };

444+ return false;

445+ });

446+};

447+var parseFixityKeyword = /* #__PURE__ */ (function () {

448+ return alt(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Infix.value))(tokKeyword("infix")))(alt(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Infixl.value))(tokKeyword("infixl")))(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Infixr.value))(tokKeyword("infixr"))));

449+})();

450+var parseFixityOp = /* #__PURE__ */ (function () {

451+ return alt(apply(apply(apply(map(PureScript_CST_Types.FixityType.create)(tokKeyword("type")))(parseQualifiedProper))(tokKeyword("as")))(parseOperator))(apply(apply(map(PureScript_CST_Types.FixityValue.create)(parseQualifiedIdentOrProper))(tokKeyword("as")))(parseOperator));

452+})();

453+var parseDeclFixity = /* #__PURE__ */ bind(parseFixityKeyword)(function (keyword) {

454+ return bind(parseSmallInt)(function (prec) {

455+ return bind(parseFixityOp)(function (operator) {

456+ return pure(new PureScript_CST_Types.DeclFixity({

457+ keyword: keyword,

458+ prec: prec,

459+ operator: operator

460+ }));

461+ });

462+ });

463+});

464+var parseForeignKind = /* #__PURE__ */ (function () {

465+ return PureScript_CST_Parser_Monad["try"](apply(map(PureScript_CST_Types.ForeignKind.create)(tokKeyword("kind")))(parseProper));

466+})();

467+var parseRole = /* #__PURE__ */ (function () {

468+ return alt(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Representational.value))(tokKeyword("representational")))(alt(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Nominal.value))(tokKeyword("nominal")))(map(Data_Function.flip(Data_Tuple.Tuple.create)(PureScript_CST_Types.Phantom.value))(tokKeyword("phantom"))));

469+})();

470+var parseDeclRole = function (keyword1) {

471+ return bind(tokKeyword("role"))(function (keyword2) {

472+ return bind(parseProper)(function (name) {

473+ return bind(many1(parseRole))(function (roles) {

474+ return pure(new PureScript_CST_Types.DeclRole(keyword1, keyword2, name, roles));

475+ });

476+ });

477+ });

478+};

479+var tokLayoutEnd = /* #__PURE__ */ expect(function (v) {

480+ if (v instanceof PureScript_CST_Types.TokLayoutEnd) {

481+ return true;

482+ };

483+ return false;

484+});

485+var tokLayoutSep = /* #__PURE__ */ expect(function (v) {

486+ if (v instanceof PureScript_CST_Types.TokLayoutSep) {

487+ return true;

488+ };

489+ return false;

490+});

491+var parseInstanceChainSeparator = /* #__PURE__ */ applyFirst(/* #__PURE__ */ tokKeyword("else"))(/* #__PURE__ */ PureScript_CST_Parser_Monad.optional(tokLayoutSep));

492+var tokLayoutStart = /* #__PURE__ */ expect(function (v) {

493+ if (v instanceof PureScript_CST_Types.TokLayoutStart) {

494+ return true;

495+ };

496+ return false;

497+});

498+var layoutNonEmpty = function (valueParser) {

499+ return apply(map(function (v) {

500+ return function (v1) {

501+ return Data_Array_NonEmpty["cons$prime"](v)(v1);

502+ };

503+ })(applySecond(tokLayoutStart)(valueParser)))(applyFirst(PureScript_CST_Parser_Monad.many(applySecond(tokLayoutSep)(valueParser)))(tokLayoutEnd));

504+};

505+var tokLeftArrow = /* #__PURE__ */ expect(function (v) {

506+ if (v instanceof PureScript_CST_Types.TokLeftArrow) {

507+ return true;

508+ };

509+ return false;

510+});

511+var tokLeftBrace = /* #__PURE__ */ expect(function (v) {

512+ if (v instanceof PureScript_CST_Types.TokLeftBrace) {

513+ return true;

514+ };

515+ return false;

516+});

517+var tokLeftFatArrow = /* #__PURE__ */ expect(function (v) {

518+ if (v instanceof PureScript_CST_Types.TokOperator && v.value0 instanceof Data_Maybe.Nothing) {

519+ return v.value1 === "<=" || v.value1 === "\u21d0";

520+ };

521+ return false;

522+});

523+var tokLeftParen = /* #__PURE__ */ expect(function (v) {

524+ if (v instanceof PureScript_CST_Types.TokLeftParen) {

525+ return true;

526+ };

527+ return false;

528+});

529+var tokLeftSquare = /* #__PURE__ */ expect(function (v) {

530+ if (v instanceof PureScript_CST_Types.TokLeftSquare) {

531+ return true;

532+ };

533+ return false;

534+});

535+var tokPipe = /* #__PURE__ */ expect(function (v) {

536+ if (v instanceof PureScript_CST_Types.TokPipe) {

537+ return true;

538+ };

539+ return false;

540+});

541+var tokQualifiedKeyword = function (kw) {

542+ return expect(function (v) {

543+ if (v instanceof PureScript_CST_Types.TokLowerName) {

544+ return kw === v.value1;

545+ };

546+ return false;

547+ });

548+};

549+var tokRightArrow = /* #__PURE__ */ expect(function (v) {

550+ if (v instanceof PureScript_CST_Types.TokRightArrow) {

551+ return true;

552+ };

553+ return false;

554+});

555+var parseFundep = /* #__PURE__ */ (function () {

556+ return alt(apply(map(PureScript_CST_Types.FundepDetermined.create)(tokRightArrow))(many1(parseIdent)))(apply(apply(map(PureScript_CST_Types.FundepDetermines.create)(many1(parseIdent)))(tokRightArrow))(many1(parseIdent)));

557+})();

558+var tokRightBrace = /* #__PURE__ */ expect(function (v) {

559+ if (v instanceof PureScript_CST_Types.TokRightBrace) {

560+ return true;

561+ };

562+ return false;

563+});

564+var tokRightFatArrow = /* #__PURE__ */ expect(function (v) {

565+ if (v instanceof PureScript_CST_Types.TokRightFatArrow) {

566+ return true;

567+ };

568+ return false;

569+});

570+var tokRightParen = /* #__PURE__ */ expect(function (v) {

571+ if (v instanceof PureScript_CST_Types.TokRightParen) {

572+ return true;

573+ };

574+ return false;

575+});

576+var parens = /* #__PURE__ */ wrapped(tokLeftParen)(tokRightParen);

577+var parseEmptyRow = function (open) {

578+ return bind(tokRightParen)(function (close) {

579+ return pure(new PureScript_CST_Types.TypeRow({

580+ open: open,

581+ value: {

582+ labels: Data_Maybe.Nothing.value,

583+ tail: Data_Maybe.Nothing.value

584+ },

585+ close: close

586+ }));

587+ });

588+};

589+var tokRightSquare = /* #__PURE__ */ expect(function (v) {

590+ if (v instanceof PureScript_CST_Types.TokRightSquare) {

591+ return true;

592+ };

593+ return false;

594+});

595+var tokSymbolArrow = /* #__PURE__ */ expect(function (v) {

596+ if (v instanceof PureScript_CST_Types.TokSymbolArrow) {

597+ return true;

598+ };

599+ return false;

600+});

601+var tokTick = /* #__PURE__ */ expect(function (v) {

602+ if (v instanceof PureScript_CST_Types.TokTick) {

603+ return true;

604+ };

605+ return false;

606+});

607+var tokUnderscore = /* #__PURE__ */ expect(function (v) {

608+ if (v instanceof PureScript_CST_Types.TokUnderscore) {

609+ return true;

610+ };

611+ return false;

612+});

613+var delimited = function (openTok) {

614+ return function (closeTok) {

615+ return function (sepTok) {

616+ return function (valueParser) {

617+ var parseNonEmpty = function (open) {

618+ return apply(map(function (v) {

619+ return function (v1) {

620+ return {

621+ open: open,

622+ value: new Data_Maybe.Just(v),

623+ close: v1

624+ };

625+ };

626+ })(separated(sepTok)(valueParser)))(closeTok);

627+ };

628+ var parseEmpty = function (open) {

629+ return map(function (v) {

630+ return {

631+ open: open,

632+ value: Data_Maybe.Nothing.value,

633+ close: v

634+ };

635+ })(closeTok);

636+ };

637+ return bind(openTok)(function (open) {

638+ return alt(parseEmpty(open))(parseNonEmpty(open));

639+ });

640+ };

641+ };

642+ };

643+};

644+var parseDataMembers = /* #__PURE__ */ (function () {

645+ return alt(map(PureScript_CST_Types.DataAll.create)(tokKeySymbol("..")))(map(PureScript_CST_Types.DataEnumerated.create)(delimited(tokLeftParen)(tokRightParen)(tokComma)(parseProper)));

646+})();

647+var parseExport = /* #__PURE__ */ (function () {

648+ return alt(apply(map(PureScript_CST_Types.ExportTypeOp.create)(tokKeyword("type")))(parseSymbol))(alt(apply(map(PureScript_CST_Types.ExportClass.create)(tokKeyword("class")))(parseProper))(alt(apply(map(PureScript_CST_Types.ExportModule.create)(tokKeyword("module")))(parseModuleName))(alt(map(PureScript_CST_Types.ExportOp.create)(parseSymbol))(alt(map(PureScript_CST_Types.ExportValue.create)(parseIdent))(apply(map(PureScript_CST_Types.ExportType.create)(parseProper))(PureScript_CST_Parser_Monad.optional(parseDataMembers)))))));

649+})();

650+var parseImport = /* #__PURE__ */ (function () {

651+ return alt(map(PureScript_CST_Types.ImportOp.create)(parseSymbol))(alt(apply(map(PureScript_CST_Types.ImportType.create)(parseProper))(PureScript_CST_Parser_Monad.optional(parseDataMembers)))(alt(apply(map(PureScript_CST_Types.ImportTypeOp.create)(tokKeyword("type")))(parseSymbol))(alt(apply(map(PureScript_CST_Types.ImportClass.create)(tokKeyword("class")))(parseProper))(map(PureScript_CST_Types.ImportValue.create)(parseIdent)))));

652+})();

653+var parseImportDecl = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("import"))(function (keyword) {

654+ return bind(parseModuleName)(function (module_) {

655+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(PureScript_CST_Parser_Monad.optional(tokKeyword("hiding"))))(parens(separated(tokComma)(parseImport)))))(function (names) {

656+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokKeyword("as")))(parseModuleName)))(function (qualified) {

657+ return pure({

658+ keyword: keyword,

659+ module: module_,

660+ names: names,

661+ qualified: qualified

662+ });

663+ });

664+ });

665+ });

666+});

667+var parseModuleImportDecls = /* #__PURE__ */ PureScript_CST_Parser_Monad.many(/* #__PURE__ */ applyFirst(parseImportDecl)(/* #__PURE__ */ alt(tokLayoutSep)(/* #__PURE__ */ PureScript_CST_Parser_Monad.lookAhead(tokLayoutEnd))));

668+var parseModuleHeader = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("module"))(function (keyword) {

669+ return bind(parseModuleName)(function (name) {

670+ return bind(PureScript_CST_Parser_Monad.optional(parens(separated(tokComma)(parseExport))))(function (exports) {

671+ return bind(tokKeyword("where"))(function (where_) {

672+ return bind(applySecond(tokLayoutStart)(parseModuleImportDecls))(function (imports) {

673+ return pure({

674+ keyword: keyword,

675+ name: name,

676+ exports: exports,

677+ where: where_,

678+ imports: imports

679+ });

680+ });

681+ });

682+ });

683+ });

684+});

685+var braces = /* #__PURE__ */ wrapped(tokLeftBrace)(tokRightBrace);

686+var parseTypeVarKinded = function (parseBindingName) {

687+ return map(PureScript_CST_Types.TypeVarKinded.create)(parens(bind(parseBindingName)(function (label) {

688+ return bind(tokDoubleColon)(function (separator) {

689+ return bind($lazy_parseType(550))(function (value) {

690+ return pure({

691+ label: label,

692+ separator: separator,

693+ value: value

694+ });

695+ });

696+ });

697+ })));

698+};

699+var parseTypeVarBinding = function (parseBindingName) {

700+ return alt(parseTypeVarKinded(parseBindingName))(map(PureScript_CST_Types.TypeVarName.create)(parseBindingName));

701+};

702+var parseTypeParen = function (open) {

703+ return bind($lazy_parseType(507))(function (value) {

704+ return bind(tokRightParen)(function (close) {

705+ return pure(new PureScript_CST_Types.TypeParens({

706+ open: open,

707+ value: value,

708+ close: close

709+ }));

710+ });

711+ });

712+};

713+var parseRowTailParen = function (open) {

714+ return bind(apply(map(Data_Tuple.Tuple.create)(tokPipe))($lazy_parseType(477)))(function (tail) {

715+ return bind(tokRightParen)(function (close) {

716+ return pure(new PureScript_CST_Types.TypeRow({

717+ open: open,

718+ value: {

719+ labels: Data_Maybe.Nothing.value,

720+ tail: new Data_Maybe.Just(tail)

721+ },

722+ close: close

723+ }));

724+ });

725+ });

726+};

727+var parseRowParen = function (open) {

728+ return bind(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseLabel))(tokDoubleColon)))(function (v) {

729+ return bind($lazy_parseType(459))(function (value) {

730+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(tokComma))($lazy_parseRowLabel(460))))(function (rest) {

731+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokPipe))($lazy_parseType(461))))(function (tail) {

732+ return bind(tokRightParen)(function (close) {

733+ return pure(new PureScript_CST_Types.TypeRow({

734+ open: open,

735+ value: {

736+ labels: new Data_Maybe.Just({

737+ head: {

738+ label: v.value0,

739+ separator: v.value1,

740+ value: value

741+ },

742+ tail: rest

743+ }),

744+ tail: tail

745+ },

746+ close: close

747+ }));

748+ });

749+ });

750+ });

751+ });

752+ });

753+};

754+var parseKindedVar = function (open) {

755+ return bind(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parens(map(PureScript_CST_Types.TypeVar.create)(parseIdent))))(tokDoubleColon)))(function (v) {

756+ return bind($lazy_parseType(497))(function (kind) {

757+ return bind(tokRightParen)(function (close) {

758+ return pure(new PureScript_CST_Types.TypeParens({

759+ open: open,

760+ value: new PureScript_CST_Types.TypeKinded(new PureScript_CST_Types.TypeParens(v.value0), v.value1, kind),

761+ close: close

762+ }));

763+ });

764+ });

765+ });

766+};

767+var $lazy_parseForall = /* #__PURE__ */ $runtime_lazy("parseForall", "PureScript.CST.Parser", function () {

768+ return defer(function (v) {

769+ return apply(apply(apply(map(PureScript_CST_Types.TypeForall.create)(tokForall))(many1($lazy_parseTypeVarBindingWithVisibility(528))))(tokDot))($lazy_parseType1(530));

770+ });

771+});

772+var $lazy_parseRow = /* #__PURE__ */ $runtime_lazy("parseRow", "PureScript.CST.Parser", function () {

773+ return defer(function (v) {

774+ return bind(PureScript_CST_Parser_Monad.optional(separated(tokComma)($lazy_parseRowLabel(513))))(function (labels) {

775+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokPipe))($lazy_parseType(514))))(function (tail) {

776+ return pure({

777+ labels: labels,

778+ tail: tail

779+ });

780+ });

781+ });

782+ });

783+});

784+var $lazy_parseRowLabel = /* #__PURE__ */ $runtime_lazy("parseRowLabel", "PureScript.CST.Parser", function () {

785+ return bind(parseLabel)(function (label) {

786+ return bind(tokDoubleColon)(function (separator) {

787+ return bind($lazy_parseType(521))(function (value) {

788+ return pure({

789+ label: label,

790+ separator: separator,

791+ value: value

792+ });

793+ });

794+ });

795+ });

796+});

797+var $lazy_parseType = /* #__PURE__ */ $runtime_lazy("parseType", "PureScript.CST.Parser", function () {

798+ return defer(function (v) {

799+ return bind($lazy_parseType1(393))(function (ty) {

800+ return alt(apply(map(PureScript_CST_Types.TypeKinded.create(ty))(tokDoubleColon))($lazy_parseType(394)))(pure(ty));

801+ });

802+ });

803+});

804+var $lazy_parseType1 = /* #__PURE__ */ $runtime_lazy("parseType1", "PureScript.CST.Parser", function () {

805+ return defer(function (v) {

806+ return alt($lazy_parseForall(399))($lazy_parseType2(400));

807+ });

808+});

809+var $lazy_parseType2 = /* #__PURE__ */ $runtime_lazy("parseType2", "PureScript.CST.Parser", function () {

810+ return defer(function (v) {

811+ return bind($lazy_parseType3(404))(function (ty) {

812+ return alt(apply(map(PureScript_CST_Types.TypeArrow.create(ty))(tokRightArrow))($lazy_parseType1(405)))(alt(apply(map(PureScript_CST_Types.TypeConstrained.create(ty))(tokRightFatArrow))($lazy_parseType1(406)))(pure(ty)));

813+ });

814+ });

815+});

816+var $lazy_parseType3 = /* #__PURE__ */ $runtime_lazy("parseType3", "PureScript.CST.Parser", function () {

817+ return defer(function (v) {

818+ return bind($lazy_parseType4(411))(function (ty) {

819+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(parseQualifiedOperator))($lazy_parseType4(412))))(function (ops) {

820+ return pure((function () {

821+ var v1 = Data_Array_NonEmpty.fromArray(ops);

822+ if (v1 instanceof Data_Maybe.Nothing) {

823+ return ty;

824+ };

825+ if (v1 instanceof Data_Maybe.Just) {

826+ return new PureScript_CST_Types.TypeOp(ty, v1.value0);

827+ };

828+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 413, column 8 - line 415, column 28): " + [ v1.constructor.name ]);

829+ })());

830+ });

831+ });

832+ });

833+});

834+var $lazy_parseType4 = /* #__PURE__ */ $runtime_lazy("parseType4", "PureScript.CST.Parser", function () {

835+ return defer(function (v) {

836+ return alt(parseTypeNegative)($lazy_parseType5(419));

837+ });

838+});

839+var $lazy_parseType5 = /* #__PURE__ */ $runtime_lazy("parseType5", "PureScript.CST.Parser", function () {

840+ return defer(function (v) {

841+ return bind($lazy_parseTypeAtom(423))(function (ty) {

842+ return bind(PureScript_CST_Parser_Monad.many($lazy_parseTypeAtom(424)))(function (args) {

843+ return pure((function () {

844+ var v1 = Data_Array_NonEmpty.fromArray(args);

845+ if (v1 instanceof Data_Maybe.Nothing) {

846+ return ty;

847+ };

848+ if (v1 instanceof Data_Maybe.Just) {

849+ return new PureScript_CST_Types.TypeApp(ty, v1.value0);

850+ };

851+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 425, column 8 - line 427, column 29): " + [ v1.constructor.name ]);

852+ })());

853+ });

854+ });

855+ });

856+});

857+var $lazy_parseTypeAtom = /* #__PURE__ */ $runtime_lazy("parseTypeAtom", "PureScript.CST.Parser", function () {

858+ return defer(function (v) {

859+ return alt(map(PureScript_CST_Types.TypeVar.create)(parseIdent))(alt(map(PureScript_CST_Types.TypeConstructor.create)(parseQualifiedProper))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.TypeString.create))(parseString))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.TypeInt.create(Data_Maybe.Nothing.value)))($$parseInt))(alt($lazy_parseTypeParens(435))(alt(map(PureScript_CST_Types.TypeRecord.create)(braces($lazy_parseRow(436))))(alt(map(PureScript_CST_Types.TypeOpName.create)(parseQualifiedSymbol))(alt(map(PureScript_CST_Types.TypeHole.create)(parseHole))(alt(map(PureScript_CST_Types.TypeWildcard.create)(tokUnderscore))(map(PureScript_CST_Types.TypeArrowName.create)(tokSymbolArrow))))))))));

860+ });

861+});

862+var $lazy_parseTypeParens = /* #__PURE__ */ $runtime_lazy("parseTypeParens", "PureScript.CST.Parser", function () {

863+ return bind(tokLeftParen)(function (open) {

864+ return alt(parseRowParen(open))(alt(parseRowTailParen(open))(alt(parseKindedVar(open))(alt(parseTypeParen(open))(parseEmptyRow(open)))));

865+ });

866+});

867+var $lazy_parseTypeVarBindingWithVisibility = /* #__PURE__ */ $runtime_lazy("parseTypeVarBindingWithVisibility", "PureScript.CST.Parser", function () {

868+ return defer(function (v) {

869+ return parseTypeVarBinding(apply(map(function (v1) {

870+ return function (v2) {

871+ return {

872+ prefix: v1,

873+ value: v2

874+ };

875+ };

876+ })(PureScript_CST_Parser_Monad.optional(tokAt)))(parseIdent));

877+ });

878+});

879+var parseForall = /* #__PURE__ */ $lazy_parseForall(524);

880+var parseRow = /* #__PURE__ */ $lazy_parseRow(511);

881+var parseRowLabel = /* #__PURE__ */ $lazy_parseRowLabel(517);

882+var parseType = /* #__PURE__ */ $lazy_parseType(391);

883+var parseType1 = /* #__PURE__ */ $lazy_parseType1(397);

884+var parseType2 = /* #__PURE__ */ $lazy_parseType2(402);

885+var parseType3 = /* #__PURE__ */ $lazy_parseType3(409);

886+var parseType4 = /* #__PURE__ */ $lazy_parseType4(417);

887+var parseType5 = /* #__PURE__ */ $lazy_parseType5(421);

888+var parseTypeAtom = /* #__PURE__ */ $lazy_parseTypeAtom(429);

889+var parseTypeParens = /* #__PURE__ */ $lazy_parseTypeParens(442);

890+var parseTypeVarBindingWithVisibility = /* #__PURE__ */ $lazy_parseTypeVarBindingWithVisibility(532);

891+var parseDataCtor = /* #__PURE__ */ apply(/* #__PURE__ */ map(function (v) {

892+ return function (v1) {

893+ return {

894+ name: v,

895+ fields: v1

896+ };

897+ };

898+})(parseProper))(/* #__PURE__ */ PureScript_CST_Parser_Monad.many(parseTypeAtom));

899+var $lazy_parseBinder = /* #__PURE__ */ $runtime_lazy("parseBinder", "PureScript.CST.Parser", function () {

900+ return defer(function (v) {

901+ return bind($lazy_parseBinder1(825))(function (binder) {

902+ return alt(apply(map(PureScript_CST_Types.BinderTyped.create(binder))(tokDoubleColon))(parseType))(pure(binder));

903+ });

904+ });

905+});

906+var $lazy_parseBinder1 = /* #__PURE__ */ $runtime_lazy("parseBinder1", "PureScript.CST.Parser", function () {

907+ return defer(function (v) {

908+ return bind($lazy_parseBinder2(831))(function (binder) {

909+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(parseQualifiedOperator))($lazy_parseBinder2(832))))(function (ops) {

910+ return pure((function () {

911+ var v1 = Data_Array_NonEmpty.fromArray(ops);

912+ if (v1 instanceof Data_Maybe.Nothing) {

913+ return binder;

914+ };

915+ if (v1 instanceof Data_Maybe.Just) {

916+ return new PureScript_CST_Types.BinderOp(binder, v1.value0);

917+ };

918+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 833, column 8 - line 835, column 34): " + [ v1.constructor.name ]);

919+ })());

920+ });

921+ });

922+ });

923+});

924+var $lazy_parseBinder2 = /* #__PURE__ */ $runtime_lazy("parseBinder2", "PureScript.CST.Parser", function () {

925+ return defer(function (v) {

926+ return alt(parseBinderNegative)(alt($lazy_parseBinderConstructor(840))($lazy_parseBinderAtom(841)));

927+ });

928+});

929+var $lazy_parseBinderAtom = /* #__PURE__ */ $runtime_lazy("parseBinderAtom", "PureScript.CST.Parser", function () {

930+ return defer(function (v) {

931+ return alt($lazy_parseIdentBinder(857))(alt(map(Data_Function.flip(PureScript_CST_Types.BinderConstructor.create)([ ]))(parseQualifiedProper))(alt(map(PureScript_CST_Types.BinderWildcard.create)(tokUnderscore))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderString.create))(parseString))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderChar.create))(parseChar))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderBoolean.create))(parseBoolean))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderInt.create(Data_Maybe.Nothing.value)))($$parseInt))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.BinderNumber.create(Data_Maybe.Nothing.value)))(parseNumber))(alt(map(PureScript_CST_Types.BinderArray.create)(delimited(tokLeftSquare)(tokRightSquare)(tokComma)($lazy_parseBinder(865))))(alt(map(PureScript_CST_Types.BinderRecord.create)(delimited(tokLeftBrace)(tokRightBrace)(tokComma)(parseRecordLabeled($lazy_parseBinder(866)))))(map(PureScript_CST_Types.BinderParens.create)(parens($lazy_parseBinder(867)))))))))))));

932+ });

933+});

934+var $lazy_parseBinderConstructor = /* #__PURE__ */ $runtime_lazy("parseBinderConstructor", "PureScript.CST.Parser", function () {

935+ return defer(function (v) {

936+ return bind(parseQualifiedProper)(function (name) {

937+ return bind(PureScript_CST_Parser_Monad.many($lazy_parseBinderAtom(852)))(function (apps) {

938+ return pure(new PureScript_CST_Types.BinderConstructor(name, apps));

939+ });

940+ });

941+ });

942+});

943+var $lazy_parseIdentBinder = /* #__PURE__ */ $runtime_lazy("parseIdentBinder", "PureScript.CST.Parser", function () {

944+ return bind(parseIdent)(function (ident) {

945+ return alt(apply(map(PureScript_CST_Types.BinderNamed.create(ident))(tokAt))($lazy_parseBinderAtom(872)))(pure(new PureScript_CST_Types.BinderVar(ident)));

946+ });

947+});

948+var parseBinder = /* #__PURE__ */ $lazy_parseBinder(823);

949+var parseBinder1 = /* #__PURE__ */ $lazy_parseBinder1(829);

950+var parseBinder2 = /* #__PURE__ */ $lazy_parseBinder2(837);

951+var parseBinderAtom = /* #__PURE__ */ $lazy_parseBinderAtom(855);

952+var parseBinderConstructor = /* #__PURE__ */ $lazy_parseBinderConstructor(849);

953+var parseIdentBinder = /* #__PURE__ */ $lazy_parseIdentBinder(869);

954+var parseClassConstraints = function (parseOneConstraint) {

955+ return alt(map(PureScript_CST_Types.Many.create)(parens(separated(tokComma)(parseType))))(map(PureScript_CST_Types.One.create)(parseOneConstraint));

956+};

957+var parseDeclDerive = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("derive"))(function (derive_) {

958+ return bind(PureScript_CST_Parser_Monad.optional(tokKeyword("newtype")))(function (newtype_) {

959+ return bind(tokKeyword("instance"))(function (keyword) {

960+ return bind(PureScript_CST_Parser_Monad.optional(parseInstanceName))(function (name) {

961+ return bind(PureScript_CST_Parser_Monad.optional(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseClassConstraints(parseType3)))(tokRightFatArrow))))(function (constraints) {

962+ return bind(parseQualifiedProper)(function (className) {

963+ return bind(PureScript_CST_Parser_Monad.many(parseTypeAtom))(function (types) {

964+ return pure(new PureScript_CST_Types.DeclDerive(derive_, newtype_, {

965+ keyword: keyword,

966+ name: name,

967+ constraints: constraints,

968+ className: className,

969+ types: types

970+ }));

971+ });

972+ });

973+ });

974+ });

975+ });

976+ });

977+});

978+var parseClassMember = /* #__PURE__ */ bind(parseIdent)(function (label) {

979+ return bind(tokDoubleColon)(function (separator) {

980+ return bind(parseType)(function (value) {

981+ return pure({

982+ label: label,

983+ separator: separator,

984+ value: value

985+ });

986+ });

987+ });

988+});

989+var parseDeclClassSignature = function (keyword) {

990+ return bind(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseProper))(tokDoubleColon)))(function (v) {

991+ return bind(parseType)(function (value) {

992+ return pure(new PureScript_CST_Types.DeclKindSignature(keyword, {

993+ label: v.value0,

994+ separator: v.value1,

995+ value: value

996+ }));

997+ });

998+ });

999+};

1000+var parseDeclKindSignature = function (keyword) {

1001+ return function (label) {

1002+ return bind(tokDoubleColon)(function (separator) {

1003+ return bind(parseType)(function (value) {

1004+ return pure(new PureScript_CST_Types.DeclKindSignature(keyword, {

1005+ label: label,

1006+ separator: separator,

1007+ value: value

1008+ }));

1009+ });

1010+ });

1011+ };

1012+};

1013+var parseDeclSignature = function (label) {

1014+ return bind(tokDoubleColon)(function (separator) {

1015+ return bind(parseType)(function (value) {

1016+ return pure(new PureScript_CST_Types.DeclSignature({

1017+ label: label,

1018+ separator: separator,

1019+ value: value

1020+ }));

1021+ });

1022+ });

1023+};

1024+var parseForeignData = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("data"))(function (keyword) {

1025+ return bind(parseProper)(function (label) {

1026+ return bind(tokDoubleColon)(function (separator) {

1027+ return bind(parseType)(function (value) {

1028+ return pure(new PureScript_CST_Types.ForeignData(keyword, {

1029+ label: label,

1030+ separator: separator,

1031+ value: value

1032+ }));

1033+ });

1034+ });

1035+ });

1036+});

1037+var parseForeignValue = /* #__PURE__ */ bind(parseIdent)(function (label) {

1038+ return bind(tokDoubleColon)(function (separator) {

1039+ return bind(parseType)(function (value) {

1040+ return pure(new PureScript_CST_Types.ForeignValue({

1041+ label: label,

1042+ separator: separator,

1043+ value: value

1044+ }));

1045+ });

1046+ });

1047+});

1048+var parseDeclForeign = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("foreign"))(function (keyword1) {

1049+ return bind(tokKeyword("import"))(function (keyword2) {

1050+ return bind(alt(parseForeignData)(alt(parseForeignKind)(parseForeignValue)))(function (foreign_) {

1051+ return pure(new PureScript_CST_Types.DeclForeign(keyword1, keyword2, foreign_));

1052+ });

1053+ });

1054+});

1055+var parseInstanceBindingSignature = function (label) {

1056+ return bind(tokDoubleColon)(function (separator) {

1057+ return bind(parseType)(function (value) {

1058+ return pure(new PureScript_CST_Types.InstanceBindingSignature({

1059+ label: label,

1060+ separator: separator,

1061+ value: value

1062+ }));

1063+ });

1064+ });

1065+};

1066+var parseLetBindingSignature = function (label) {

1067+ return bind(tokDoubleColon)(function (separator) {

1068+ return bind(parseType)(function (value) {

1069+ return pure(new PureScript_CST_Types.LetBindingSignature({

1070+ label: label,

1071+ separator: separator,

1072+ value: value

1073+ }));

1074+ });

1075+ });

1076+};

1077+var parseRecordUpdates = function (expr) {

1078+ return bind(PureScript_CST_Parser_Monad["try"](applyFirst(tokLeftBrace)(PureScript_CST_Parser_Monad.lookAhead(applySecond(parseLabel)(alt(tokEquals)(tokLeftBrace))))))(function (open) {

1079+ return bind(separated(tokComma)($lazy_parseRecordUpdate(709)))(function (value) {

1080+ return bind(tokRightBrace)(function (close) {

1081+ return pure(new PureScript_CST_Types.ExprRecordUpdate(expr, {

1082+ open: open,

1083+ value: value,

1084+ close: close

1085+ }));

1086+ });

1087+ });

1088+ });

1089+};

1090+var parseRecordUpdateLeaf = function (label) {

1091+ return apply(map(PureScript_CST_Types.RecordUpdateLeaf.create(label))(tokEquals))($lazy_parseExpr(723));

1092+};

1093+var parseRecordUpdateBranch = function (label) {

1094+ return map(PureScript_CST_Types.RecordUpdateBranch.create(label))(braces(separated(tokComma)($lazy_parseRecordUpdate(728))));

1095+};

1096+var parseLetBindingName = function (name) {

1097+ return bind(PureScript_CST_Parser_Monad.many(parseBinderAtom))(function (binders) {

1098+ return bind(parseGuarded(tokEquals))(function (guarded) {

1099+ return pure(new PureScript_CST_Types.LetBindingName({

1100+ name: name,

1101+ binders: binders,

1102+ guarded: guarded

1103+ }));

1104+ });

1105+ });

1106+};

1107+var parseGuarded = function (sepParser) {

1108+ var parsePatternGuard = apply(map(function (v) {

1109+ return function (v1) {

1110+ return {

1111+ binder: v,

1112+ expr: v1

1113+ };

1114+ };

1115+ })(PureScript_CST_Parser_Monad.optional(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseBinder))(tokLeftArrow)))))($lazy_parseExpr(814));

1116+ var parseGuardedExpr = apply(apply(apply(map(function (v) {

1117+ return function (v1) {

1118+ return function (v2) {

1119+ return function (v3) {

1120+ return {

1121+ bar: v,

1122+ patterns: v1,

1123+ separator: v2,

1124+ where: v3

1125+ };

1126+ };

1127+ };

1128+ };

1129+ })(tokPipe))(separated(tokComma)(parsePatternGuard)))(sepParser))($lazy_parseWhere(808));

1130+ return alt(apply(map(PureScript_CST_Types.Unconditional.create)(sepParser))($lazy_parseWhere(800)))(map(PureScript_CST_Types.Guarded.create)(many1(parseGuardedExpr)));

1131+};

1132+var parseBadSingleCaseWhere = function (binder) {

1133+ return bind(tokRightArrow)(function (arrow) {

1134+ return bind(applySecond(tokLayoutEnd)($lazy_parseWhere(665)))(function (body) {

1135+ return pure(Data_Array_NonEmpty.singleton(new Data_Tuple.Tuple({

1136+ head: binder,

1137+ tail: [ ]

1138+ }, new PureScript_CST_Types.Unconditional(arrow, body))));

1139+ });

1140+ });

1141+};

1142+var parseBadSingleCaseGuarded = function (binder) {

1143+ return bind(applySecond(tokLayoutEnd)(parseGuarded(tokRightArrow)))(function (body) {

1144+ return pure(Data_Array_NonEmpty.singleton(new Data_Tuple.Tuple({

1145+ head: binder,

1146+ tail: [ ]

1147+ }, body)));

1148+ });

1149+};

1150+var $lazy_parseAdo = /* #__PURE__ */ $runtime_lazy("parseAdo", "PureScript.CST.Parser", function () {

1151+ return bind(tokQualifiedKeyword("ado"))(function (keyword) {

1152+ return bind((function () {

1153+ var valueParser = recoverDoStatement($lazy_parseDoStatement(690));

1154+ var nonEmptyCase = apply(map(Data_Array.cons)(valueParser))(PureScript_CST_Parser_Monad.many(applySecond(tokLayoutSep)(valueParser)));

1155+ return bind(tokLayoutStart)(function () {

1156+ return alt(voidRight([ ])(tokLayoutEnd))(applyFirst(nonEmptyCase)(tokLayoutEnd));

1157+ });

1158+ })())(function (statements) {

1159+ return bind(tokKeyword("in"))(function (in_) {

1160+ return bind($lazy_parseExpr(697))(function (result) {

1161+ return pure(new PureScript_CST_Types.ExprAdo({

1162+ keyword: keyword,

1163+ statements: statements,

1164+ "in": in_,

1165+ result: result

1166+ }));

1167+ });

1168+ });

1169+ });

1170+ });

1171+});

1172+var $lazy_parseBadSingleCaseBranch = /* #__PURE__ */ $runtime_lazy("parseBadSingleCaseBranch", "PureScript.CST.Parser", function () {

1173+ return bind(applySecond(tokLayoutStart)(parseBinder1))(function (binder) {

1174+ return alt(parseBadSingleCaseWhere(binder))(parseBadSingleCaseGuarded(binder));

1175+ });

1176+});

1177+var $lazy_parseCase = /* #__PURE__ */ $runtime_lazy("parseCase", "PureScript.CST.Parser", function () {

1178+ return bind(tokKeyword("case"))(function (keyword) {

1179+ return bind(separated(tokComma)($lazy_parseExpr(647)))(function (head) {

1180+ return bind(tokKeyword("of"))(function (of_) {

1181+ return bind(alt(PureScript_CST_Parser_Monad["try"]($lazy_parseBadSingleCaseBranch(649)))($lazy_parseCaseBranches(649)))(function (branches) {

1182+ return pure(new PureScript_CST_Types.ExprCase({

1183+ keyword: keyword,

1184+ head: head,

1185+ of: of_,

1186+ branches: branches

1187+ }));

1188+ });

1189+ });

1190+ });

1191+ });

1192+});

1193+var $lazy_parseCaseBranches = /* #__PURE__ */ $runtime_lazy("parseCaseBranches", "PureScript.CST.Parser", function () {

1194+ return defer(function (v) {

1195+ return layoutNonEmpty(apply(map(Data_Tuple.Tuple.create)(separated(tokComma)(parseBinder1)))(parseGuarded(tokRightArrow)));

1196+ });

1197+});

1198+var $lazy_parseDo = /* #__PURE__ */ $runtime_lazy("parseDo", "PureScript.CST.Parser", function () {

1199+ return bind(tokQualifiedKeyword("do"))(function (keyword) {

1200+ return bind(layoutNonEmpty(recoverDoStatement($lazy_parseDoStatement(676))))(function (statements) {

1201+ return pure(new PureScript_CST_Types.ExprDo({

1202+ keyword: keyword,

1203+ statements: statements

1204+ }));

1205+ });

1206+ });

1207+});

1208+var $lazy_parseDoStatement = /* #__PURE__ */ $runtime_lazy("parseDoStatement", "PureScript.CST.Parser", function () {

1209+ return defer(function (v) {

1210+ return alt(apply(map(PureScript_CST_Types.DoLet.create)(tokKeyword("let")))(layoutNonEmpty(recoverLetBinding($lazy_parseLetBinding(771)))))(alt(apply(map(Data_Tuple.uncurry(PureScript_CST_Types.DoBind.create))(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseBinder))(tokLeftArrow))))($lazy_parseExpr(772)))(map(PureScript_CST_Types.DoDiscard.create)($lazy_parseExpr(773))));

1211+ });

1212+});

1213+var $lazy_parseExpr = /* #__PURE__ */ $runtime_lazy("parseExpr", "PureScript.CST.Parser", function () {

1214+ return defer(function (v) {

1215+ return bind($lazy_parseExpr1(555))(function (expr) {

1216+ return alt(apply(map(PureScript_CST_Types.ExprTyped.create(expr))(tokDoubleColon))(parseType))(pure(expr));

1217+ });

1218+ });

1219+});

1220+var $lazy_parseExpr1 = /* #__PURE__ */ $runtime_lazy("parseExpr1", "PureScript.CST.Parser", function () {

1221+ return defer(function (v) {

1222+ return bind($lazy_parseExpr2(561))(function (expr) {

1223+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(parseQualifiedOperator))($lazy_parseExpr2(562))))(function (ops) {

1224+ return pure((function () {

1225+ var v1 = Data_Array_NonEmpty.fromArray(ops);

1226+ if (v1 instanceof Data_Maybe.Nothing) {

1227+ return expr;

1228+ };

1229+ if (v1 instanceof Data_Maybe.Just) {

1230+ return new PureScript_CST_Types.ExprOp(expr, v1.value0);

1231+ };

1232+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 563, column 8 - line 565, column 30): " + [ v1.constructor.name ]);

1233+ })());

1234+ });

1235+ });

1236+ });

1237+});

1238+var $lazy_parseExpr2 = /* #__PURE__ */ $runtime_lazy("parseExpr2", "PureScript.CST.Parser", function () {

1239+ return defer(function (v) {

1240+ return bind($lazy_parseExpr3(569))(function (expr) {

1241+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)($lazy_parseTickExpr(570)))($lazy_parseExpr3(570))))(function (ops) {

1242+ return pure((function () {

1243+ var v1 = Data_Array_NonEmpty.fromArray(ops);

1244+ if (v1 instanceof Data_Maybe.Nothing) {

1245+ return expr;

1246+ };

1247+ if (v1 instanceof Data_Maybe.Just) {

1248+ return new PureScript_CST_Types.ExprInfix(expr, v1.value0);

1249+ };

1250+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 571, column 8 - line 573, column 33): " + [ v1.constructor.name ]);

1251+ })());

1252+ });

1253+ });

1254+ });

1255+});

1256+var $lazy_parseExpr3 = /* #__PURE__ */ $runtime_lazy("parseExpr3", "PureScript.CST.Parser", function () {

1257+ return defer(function (v) {

1258+ return alt(apply(map(PureScript_CST_Types.ExprNegate.create)(tokKeyOperator("-")))($lazy_parseExpr3(592)))($lazy_parseExpr4(593));

1259+ });

1260+});

1261+var $lazy_parseExpr4 = /* #__PURE__ */ $runtime_lazy("parseExpr4", "PureScript.CST.Parser", function () {

1262+ return defer(function (v) {

1263+ return bind($lazy_parseExpr5(597))(function (expr) {

1264+ return bind(PureScript_CST_Parser_Monad.many($lazy_parseExprAppSpine(598)))(function (args) {

1265+ return pure((function () {

1266+ var v1 = Data_Array_NonEmpty.fromArray(args);

1267+ if (v1 instanceof Data_Maybe.Nothing) {

1268+ return expr;

1269+ };

1270+ if (v1 instanceof Data_Maybe.Just) {

1271+ return new PureScript_CST_Types.ExprApp(expr, v1.value0);

1272+ };

1273+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 599, column 8 - line 601, column 31): " + [ v1.constructor.name ]);

1274+ })());

1275+ });

1276+ });

1277+ });

1278+});

1279+var $lazy_parseExpr5 = /* #__PURE__ */ $runtime_lazy("parseExpr5", "PureScript.CST.Parser", function () {

1280+ return defer(function (v) {

1281+ return alt($lazy_parseIf(605))(alt($lazy_parseLetIn(606))(alt($lazy_parseLambda(607))(alt($lazy_parseCase(608))(alt($lazy_parseDo(609))(alt($lazy_parseAdo(610))($lazy_parseExpr6(611)))))));

1282+ });

1283+});

1284+var $lazy_parseExpr6 = /* #__PURE__ */ $runtime_lazy("parseExpr6", "PureScript.CST.Parser", function () {

1285+ return defer(function (v) {

1286+ return bind($lazy_parseExpr7(702))(function (expr) {

1287+ return alt(parseRecordUpdates(expr))(pure(expr));

1288+ });

1289+ });

1290+});

1291+var $lazy_parseExpr7 = /* #__PURE__ */ $runtime_lazy("parseExpr7", "PureScript.CST.Parser", function () {

1292+ return defer(function (v) {

1293+ return bind($lazy_parseExprAtom(732))(function (expr) {

1294+ return alt(parseRecordAccessor(expr))(pure(expr));

1295+ });

1296+ });

1297+});

1298+var $lazy_parseExprAppSpine = /* #__PURE__ */ $runtime_lazy("parseExprAppSpine", "PureScript.CST.Parser", function () {

1299+ return defer(function (v) {

1300+ return alt(apply(map(PureScript_CST_Types.AppType.create)(tokAt))(parseTypeAtom))(map(PureScript_CST_Types.AppTerm.create)($lazy_parseExpr5(616)));

1301+ });

1302+});

1303+var $lazy_parseExprAtom = /* #__PURE__ */ $runtime_lazy("parseExprAtom", "PureScript.CST.Parser", function () {

1304+ return defer(function (v) {

1305+ return alt(map(PureScript_CST_Types.ExprIdent.create)(parseQualifiedIdent))(alt(map(PureScript_CST_Types.ExprConstructor.create)(parseQualifiedProper))(alt(map(PureScript_CST_Types.ExprOpName.create)(parseQualifiedSymbol))(alt(map(PureScript_CST_Types.ExprSection.create)(tokUnderscore))(alt(map(PureScript_CST_Types.ExprHole.create)(parseHole))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.ExprString.create))(parseString))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.ExprChar.create))(parseChar))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.ExprBoolean.create))(parseBoolean))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.ExprInt.create))($$parseInt))(alt(map(Data_Tuple.uncurry(PureScript_CST_Types.ExprNumber.create))(parseNumber))(alt(map(PureScript_CST_Types.ExprArray.create)(delimited(tokLeftSquare)(tokRightSquare)(tokComma)($lazy_parseExpr(754))))(alt(map(PureScript_CST_Types.ExprRecord.create)(delimited(tokLeftBrace)(tokRightBrace)(tokComma)(parseRecordLabeled($lazy_parseExpr(755)))))(map(PureScript_CST_Types.ExprParens.create)(parens($lazy_parseExpr(756)))))))))))))));

1306+ });

1307+});

1308+var $lazy_parseIdentBinding = /* #__PURE__ */ $runtime_lazy("parseIdentBinding", "PureScript.CST.Parser", function () {

1309+ return bind(parseIdent)(function (ident) {

1310+ return alt(parseLetBindingSignature(ident))(parseLetBindingName(ident));

1311+ });

1312+});

1313+var $lazy_parseIf = /* #__PURE__ */ $runtime_lazy("parseIf", "PureScript.CST.Parser", function () {

1314+ return bind(tokKeyword("if"))(function (keyword) {

1315+ return bind($lazy_parseExpr(621))(function (cond) {

1316+ return bind(tokKeyword("then"))(function (then_) {

1317+ return bind($lazy_parseExpr(623))(function (true_) {

1318+ return bind(tokKeyword("else"))(function (else_) {

1319+ return bind($lazy_parseExpr(625))(function (false_) {

1320+ return pure(new PureScript_CST_Types.ExprIf({

1321+ keyword: keyword,

1322+ cond: cond,

1323+ then: then_,

1324+ "true": true_,

1325+ "else": else_,

1326+ "false": false_

1327+ }));

1328+ });

1329+ });

1330+ });

1331+ });

1332+ });

1333+ });

1334+});

1335+var $lazy_parseLambda = /* #__PURE__ */ $runtime_lazy("parseLambda", "PureScript.CST.Parser", function () {

1336+ return bind(tokBackslash)(function (symbol) {

1337+ return bind(many1(parseBinderAtom))(function (binders) {

1338+ return bind(tokRightArrow)(function (arrow) {

1339+ return bind($lazy_parseExpr(641))(function (body) {

1340+ return pure(new PureScript_CST_Types.ExprLambda({

1341+ symbol: symbol,

1342+ binders: binders,

1343+ arrow: arrow,

1344+ body: body

1345+ }));

1346+ });

1347+ });

1348+ });

1349+ });

1350+});

1351+var $lazy_parseLetBinding = /* #__PURE__ */ $runtime_lazy("parseLetBinding", "PureScript.CST.Parser", function () {

1352+ return defer(function (v) {

1353+ return alt(PureScript_CST_Parser_Monad["try"]($lazy_parseIdentBinding(777)))(apply(apply(map(PureScript_CST_Types.LetBindingPattern.create)(parseBinder1))(tokEquals))($lazy_parseWhere(778)));

1354+ });

1355+});

1356+var $lazy_parseLetIn = /* #__PURE__ */ $runtime_lazy("parseLetIn", "PureScript.CST.Parser", function () {

1357+ return bind(tokKeyword("let"))(function (keyword) {

1358+ return bind(layoutNonEmpty(recoverLetBinding($lazy_parseLetBinding(631))))(function (bindings) {

1359+ return bind(tokKeyword("in"))(function (in_) {

1360+ return bind($lazy_parseExpr(633))(function (body) {

1361+ return pure(new PureScript_CST_Types.ExprLet({

1362+ keyword: keyword,

1363+ bindings: bindings,

1364+ "in": in_,

1365+ body: body

1366+ }));

1367+ });

1368+ });

1369+ });

1370+ });

1371+});

1372+var $lazy_parseRecordUpdate = /* #__PURE__ */ $runtime_lazy("parseRecordUpdate", "PureScript.CST.Parser", function () {

1373+ return bind(parseLabel)(function (label) {

1374+ return alt(parseRecordUpdateLeaf(label))(parseRecordUpdateBranch(label));

1375+ });

1376+});

1377+var $lazy_parseTickExpr = /* #__PURE__ */ $runtime_lazy("parseTickExpr", "PureScript.CST.Parser", function () {

1378+ return bind(tokTick)(function (open) {

1379+ return bind($lazy_parseTickExpr1(578))(function (value) {

1380+ return bind(tokTick)(function (close) {

1381+ return pure({

1382+ open: open,

1383+ value: value,

1384+ close: close

1385+ });

1386+ });

1387+ });

1388+ });

1389+});

1390+var $lazy_parseTickExpr1 = /* #__PURE__ */ $runtime_lazy("parseTickExpr1", "PureScript.CST.Parser", function () {

1391+ return defer(function (v) {

1392+ return bind($lazy_parseExpr3(584))(function (expr) {

1393+ return bind(PureScript_CST_Parser_Monad.many(apply(map(Data_Tuple.Tuple.create)(parseQualifiedOperator))($lazy_parseExpr3(585))))(function (ops) {

1394+ return pure((function () {

1395+ var v1 = Data_Array_NonEmpty.fromArray(ops);

1396+ if (v1 instanceof Data_Maybe.Nothing) {

1397+ return expr;

1398+ };

1399+ if (v1 instanceof Data_Maybe.Just) {

1400+ return new PureScript_CST_Types.ExprOp(expr, v1.value0);

1401+ };

1402+ throw new Error("Failed pattern match at PureScript.CST.Parser (line 586, column 8 - line 588, column 30): " + [ v1.constructor.name ]);

1403+ })());

1404+ });

1405+ });

1406+ });

1407+});

1408+var $lazy_parseWhere = /* #__PURE__ */ $runtime_lazy("parseWhere", "PureScript.CST.Parser", function () {

1409+ return defer(function (v) {

1410+ return bind($lazy_parseExpr(819))(function (expr) {

1411+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokKeyword("where")))(layoutNonEmpty(recoverLetBinding($lazy_parseLetBinding(820))))))(function (bindings) {

1412+ return pure({

1413+ expr: expr,

1414+ bindings: bindings

1415+ });

1416+ });

1417+ });

1418+ });

1419+});

1420+var parseAdo = /* #__PURE__ */ $lazy_parseAdo(679);

1421+var parseBadSingleCaseBranch = /* #__PURE__ */ $lazy_parseBadSingleCaseBranch(656);

1422+var parseCase = /* #__PURE__ */ $lazy_parseCase(644);

1423+var parseCaseBranches = /* #__PURE__ */ $lazy_parseCaseBranches(652);

1424+var parseDo = /* #__PURE__ */ $lazy_parseDo(673);

1425+var parseDoStatement = /* #__PURE__ */ $lazy_parseDoStatement(769);

1426+var parseExpr = /* #__PURE__ */ $lazy_parseExpr(553);

1427+var parseExpr1 = /* #__PURE__ */ $lazy_parseExpr1(559);

1428+var parseExpr2 = /* #__PURE__ */ $lazy_parseExpr2(567);

1429+var parseExpr3 = /* #__PURE__ */ $lazy_parseExpr3(590);

1430+var parseExpr4 = /* #__PURE__ */ $lazy_parseExpr4(595);

1431+var parseExpr5 = /* #__PURE__ */ $lazy_parseExpr5(603);

1432+var parseExpr6 = /* #__PURE__ */ $lazy_parseExpr6(700);

1433+var parseExpr7 = /* #__PURE__ */ $lazy_parseExpr7(730);

1434+var parseExprAppSpine = /* #__PURE__ */ $lazy_parseExprAppSpine(613);

1435+var parseExprAtom = /* #__PURE__ */ $lazy_parseExprAtom(742);

1436+var parseIdentBinding = /* #__PURE__ */ $lazy_parseIdentBinding(780);

1437+var parseIf = /* #__PURE__ */ $lazy_parseIf(618);

1438+var parseLambda = /* #__PURE__ */ $lazy_parseLambda(636);

1439+var parseLetBinding = /* #__PURE__ */ $lazy_parseLetBinding(775);

1440+var parseLetIn = /* #__PURE__ */ $lazy_parseLetIn(628);

1441+var parseRecordUpdate = /* #__PURE__ */ $lazy_parseRecordUpdate(713);

1442+var parseTickExpr = /* #__PURE__ */ $lazy_parseTickExpr(575);

1443+var parseTickExpr1 = /* #__PURE__ */ $lazy_parseTickExpr1(582);

1444+var parseWhere = /* #__PURE__ */ $lazy_parseWhere(817);

1445+var parseDeclValue1 = function (name) {

1446+ return bind(PureScript_CST_Parser_Monad.many(parseBinderAtom))(function (binders) {

1447+ return bind(parseGuarded(tokEquals))(function (guarded) {

1448+ return pure(new PureScript_CST_Types.DeclValue({

1449+ name: name,

1450+ binders: binders,

1451+ guarded: guarded

1452+ }));

1453+ });

1454+ });

1455+};

1456+var parseDeclValue = /* #__PURE__ */ bind(parseIdent)(function (ident) {

1457+ return alt(parseDeclSignature(ident))(parseDeclValue1(ident));

1458+});

1459+var parseInstanceBindingName = function (name) {

1460+ return bind(PureScript_CST_Parser_Monad.many(parseBinderAtom))(function (binders) {

1461+ return bind(parseGuarded(tokEquals))(function (guarded) {

1462+ return pure(new PureScript_CST_Types.InstanceBindingName({

1463+ name: name,

1464+ binders: binders,

1465+ guarded: guarded

1466+ }));

1467+ });

1468+ });

1469+};

1470+var parseInstanceBinding = /* #__PURE__ */ bind(parseIdent)(function (ident) {

1471+ return alt(parseInstanceBindingSignature(ident))(parseInstanceBindingName(ident));

1472+});

1473+var parseInstance = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("instance"))(function (keyword) {

1474+ return bind(PureScript_CST_Parser_Monad.optional(parseInstanceName))(function (name) {

1475+ return bind(PureScript_CST_Parser_Monad.optional(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseClassConstraints(parseType3)))(tokRightFatArrow))))(function (constraints) {

1476+ return bind(parseQualifiedProper)(function (className) {

1477+ return bind(PureScript_CST_Parser_Monad.many(parseTypeAtom))(function (types) {

1478+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokKeyword("where")))(layoutNonEmpty(parseInstanceBinding))))(function (body) {

1479+ return pure({

1480+ head: {

1481+ keyword: keyword,

1482+ name: name,

1483+ constraints: constraints,

1484+ className: className,

1485+ types: types

1486+ },

1487+ body: body

1488+ });

1489+ });

1490+ });

1491+ });

1492+ });

1493+ });

1494+});

1495+var parseDeclInstanceChain = /* #__PURE__ */ (function () {

1496+ return map(PureScript_CST_Types.DeclInstanceChain.create)(separated(parseInstanceChainSeparator)(parseInstance));

1497+})();

1498+var parseTypeVarBindingPlain = /* #__PURE__ */ parseTypeVarBinding(parseIdent);

1499+var parseDeclClass1 = function (keyword) {

1500+ return bind(PureScript_CST_Parser_Monad.optional(PureScript_CST_Parser_Monad["try"](apply(map(Data_Tuple.Tuple.create)(parseClassConstraints(parseType5)))(tokLeftFatArrow))))(function ($$super) {

1501+ return bind(parseProper)(function (name) {

1502+ return bind(PureScript_CST_Parser_Monad.many(parseTypeVarBindingPlain))(function (vars) {

1503+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokPipe))(separated(tokComma)(parseFundep))))(function (fundeps) {

1504+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokKeyword("where")))(layoutNonEmpty(parseClassMember))))(function (members) {

1505+ return pure(new PureScript_CST_Types.DeclClass({

1506+ keyword: keyword,

1507+ "super": $$super,

1508+ name: name,

1509+ vars: vars,

1510+ fundeps: fundeps

1511+ }, members));

1512+ });

1513+ });

1514+ });

1515+ });

1516+ });

1517+};

1518+var parseDeclClass = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("class"))(function (keyword) {

1519+ return alt(parseDeclClassSignature(keyword))(parseDeclClass1(keyword));

1520+});

1521+var parseDeclData1 = function (keyword) {

1522+ return function (name) {

1523+ return bind(PureScript_CST_Parser_Monad.many(parseTypeVarBindingPlain))(function (vars) {

1524+ return bind(PureScript_CST_Parser_Monad.optional(apply(map(Data_Tuple.Tuple.create)(tokEquals))(separated(tokPipe)(parseDataCtor))))(function (ctors) {

1525+ return pure(new PureScript_CST_Types.DeclData({

1526+ keyword: keyword,

1527+ name: name,

1528+ vars: vars

1529+ }, ctors));

1530+ });

1531+ });

1532+ };

1533+};

1534+var parseDeclData = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("data"))(function (keyword) {

1535+ return bind(parseProper)(function (name) {

1536+ return alt(parseDeclKindSignature(keyword)(name))(parseDeclData1(keyword)(name));

1537+ });

1538+});

1539+var parseDeclNewtype1 = function (keyword) {

1540+ return function (name) {

1541+ return bind(PureScript_CST_Parser_Monad.many(parseTypeVarBindingPlain))(function (vars) {

1542+ return bind(tokEquals)(function (tok) {

1543+ return bind(parseProper)(function (wrapper) {

1544+ return bind(parseTypeAtom)(function (body) {

1545+ return pure(new PureScript_CST_Types.DeclNewtype({

1546+ keyword: keyword,

1547+ name: name,

1548+ vars: vars

1549+ }, tok, wrapper, body));

1550+ });

1551+ });

1552+ });

1553+ });

1554+ };

1555+};

1556+var parseDeclNewtype = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("newtype"))(function (keyword) {

1557+ return bind(parseProper)(function (name) {

1558+ return alt(parseDeclKindSignature(keyword)(name))(parseDeclNewtype1(keyword)(name));

1559+ });

1560+});

1561+var parseDeclType2 = function (keyword) {

1562+ return function (name) {

1563+ return bind(PureScript_CST_Parser_Monad.many(parseTypeVarBindingPlain))(function (vars) {

1564+ return bind(tokEquals)(function (tok) {

1565+ return bind(parseType)(function (body) {

1566+ return pure(new PureScript_CST_Types.DeclType({

1567+ keyword: keyword,

1568+ name: name,

1569+ vars: vars

1570+ }, tok, body));

1571+ });

1572+ });

1573+ });

1574+ };

1575+};

1576+var parseDeclType1 = function (keyword) {

1577+ return bind(parseProper)(function (name) {

1578+ return alt(parseDeclKindSignature(keyword)(name))(parseDeclType2(keyword)(name));

1579+ });

1580+};

1581+var parseDeclType = /* #__PURE__ */ bind(/* #__PURE__ */ tokKeyword("type"))(function (keyword) {

1582+ return alt(parseDeclRole(keyword))(parseDeclType1(keyword));

1583+});

1584+var parseDecl = /* #__PURE__ */ alt(parseDeclData)(/* #__PURE__ */ alt(parseDeclNewtype)(/* #__PURE__ */ alt(parseDeclType)(/* #__PURE__ */ alt(parseDeclClass)(/* #__PURE__ */ alt(parseDeclInstanceChain)(/* #__PURE__ */ alt(parseDeclDerive)(/* #__PURE__ */ alt(parseDeclValue)(/* #__PURE__ */ alt(parseDeclForeign)(parseDeclFixity))))))));

1585+var parseModuleDecls = /* #__PURE__ */ PureScript_CST_Parser_Monad.many(/* #__PURE__ */ applyFirst(/* #__PURE__ */ recoverDecl(parseDecl))(/* #__PURE__ */ alt(tokLayoutSep)(/* #__PURE__ */ PureScript_CST_Parser_Monad.lookAhead(tokLayoutEnd))));

1586+var parseModuleBody = /* #__PURE__ */ bind(/* #__PURE__ */ applyFirst(parseModuleDecls)(tokLayoutEnd))(function (decls) {

1587+ return bind(PureScript_CST_Parser_Monad.eof)(function (v) {

1588+ return pure({

1589+ decls: decls,

1590+ trailingComments: v.value1,

1591+ end: v.value0

1592+ });

1593+ });

1594+});

1595+var parseModule = /* #__PURE__ */ bind(parseModuleHeader)(function (header) {

1596+ return bind(parseModuleBody)(function (body) {

1597+ return pure({

1598+ header: header,

1599+ body: body

1600+ });

1601+ });

1602+});

1603+export {

1604+ parseModule,

1605+ parseModuleHeader,

1606+ parseModuleBody,

1607+ parseImportDecl,

1608+ parseDecl,

1609+ parseType,

1610+ parseExpr,

1611+ parseBinder

1612+};

output-compile-fail/PureScript.CST.Print/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Print/index.jsnew file+238

@@ -0,0 +1,238 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Foldable from "../Data.Foldable/index.js";

3+import * as Data_Maybe from "../Data.Maybe/index.js";

4+import * as Data_Monoid from "../Data.Monoid/index.js";

5+import * as Data_Newtype from "../Data.Newtype/index.js";

6+import * as Data_Void from "../Data.Void/index.js";

7+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

8+var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();

9+var power = /* #__PURE__ */ Data_Monoid.power(Data_Monoid.monoidString);

10+var foldMap = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableArray)(Data_Monoid.monoidString);

11+var ShowLayout = /* #__PURE__ */ (function () {

12+ function ShowLayout() {

13+

14+ };

15+ ShowLayout.value = new ShowLayout();

16+ return ShowLayout;

17+})();

18+var HideLayout = /* #__PURE__ */ (function () {

19+ function HideLayout() {

20+

21+ };

22+ HideLayout.value = new HideLayout();

23+ return HideLayout;

24+})();

25+var printQualified = function (moduleName) {

26+ return function (name) {

27+ if (moduleName instanceof Data_Maybe.Nothing) {

28+ return name;

29+ };

30+ if (moduleName instanceof Data_Maybe.Just) {

31+ return unwrap(moduleName.value0) + ("." + name);

32+ };

33+ throw new Error("Failed pattern match at PureScript.CST.Print (line 124, column 34 - line 126, column 38): " + [ moduleName.constructor.name ]);

34+ };

35+};

36+var printTokenWithOption = function (option) {

37+ return function (v) {

38+ if (v instanceof PureScript_CST_Types.TokLeftParen) {

39+ return "(";

40+ };

41+ if (v instanceof PureScript_CST_Types.TokRightParen) {

42+ return ")";

43+ };

44+ if (v instanceof PureScript_CST_Types.TokLeftBrace) {

45+ return "{";

46+ };

47+ if (v instanceof PureScript_CST_Types.TokRightBrace) {

48+ return "}";

49+ };

50+ if (v instanceof PureScript_CST_Types.TokLeftSquare) {

51+ return "[";

52+ };

53+ if (v instanceof PureScript_CST_Types.TokRightSquare) {

54+ return "]";

55+ };

56+ if (v instanceof PureScript_CST_Types.TokLeftArrow) {

57+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

58+ return "<-";

59+ };

60+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

61+ return "\u2190";

62+ };

63+ throw new Error("Failed pattern match at PureScript.CST.Print (line 51, column 5 - line 53, column 21): " + [ v.value0.constructor.name ]);

64+ };

65+ if (v instanceof PureScript_CST_Types.TokRightArrow) {

66+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

67+ return "->";

68+ };

69+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

70+ return "\u2192";

71+ };

72+ throw new Error("Failed pattern match at PureScript.CST.Print (line 55, column 5 - line 57, column 21): " + [ v.value0.constructor.name ]);

73+ };

74+ if (v instanceof PureScript_CST_Types.TokRightFatArrow) {

75+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

76+ return "=>";

77+ };

78+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

79+ return "\u21d2";

80+ };

81+ throw new Error("Failed pattern match at PureScript.CST.Print (line 59, column 5 - line 61, column 21): " + [ v.value0.constructor.name ]);

82+ };

83+ if (v instanceof PureScript_CST_Types.TokDoubleColon) {

84+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

85+ return "::";

86+ };

87+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

88+ return "\u2237";

89+ };

90+ throw new Error("Failed pattern match at PureScript.CST.Print (line 63, column 5 - line 65, column 21): " + [ v.value0.constructor.name ]);

91+ };

92+ if (v instanceof PureScript_CST_Types.TokForall) {

93+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

94+ return "forall";

95+ };

96+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

97+ return "\u2200";

98+ };

99+ throw new Error("Failed pattern match at PureScript.CST.Print (line 67, column 5 - line 69, column 21): " + [ v.value0.constructor.name ]);

100+ };

101+ if (v instanceof PureScript_CST_Types.TokEquals) {

102+ return "=";

103+ };

104+ if (v instanceof PureScript_CST_Types.TokPipe) {

105+ return "|";

106+ };

107+ if (v instanceof PureScript_CST_Types.TokTick) {

108+ return "`";

109+ };

110+ if (v instanceof PureScript_CST_Types.TokDot) {

111+ return ".";

112+ };

113+ if (v instanceof PureScript_CST_Types.TokComma) {

114+ return ",";

115+ };

116+ if (v instanceof PureScript_CST_Types.TokUnderscore) {

117+ return "_";

118+ };

119+ if (v instanceof PureScript_CST_Types.TokBackslash) {

120+ return "\\";

121+ };

122+ if (v instanceof PureScript_CST_Types.TokAt) {

123+ return "@";

124+ };

125+ if (v instanceof PureScript_CST_Types.TokLowerName) {

126+ return printQualified(v.value0)(v.value1);

127+ };

128+ if (v instanceof PureScript_CST_Types.TokUpperName) {

129+ return printQualified(v.value0)(v.value1);

130+ };

131+ if (v instanceof PureScript_CST_Types.TokOperator) {

132+ return printQualified(v.value0)(v.value1);

133+ };

134+ if (v instanceof PureScript_CST_Types.TokSymbolName) {

135+ return printQualified(v.value0)("(" + (v.value1 + ")"));

136+ };

137+ if (v instanceof PureScript_CST_Types.TokSymbolArrow) {

138+ if (v.value0 instanceof PureScript_CST_Types.ASCII) {

139+ return "(->)";

140+ };

141+ if (v.value0 instanceof PureScript_CST_Types.Unicode) {

142+ return "(\u2192)";

143+ };

144+ throw new Error("Failed pattern match at PureScript.CST.Print (line 95, column 5 - line 97, column 23): " + [ v.value0.constructor.name ]);

145+ };

146+ if (v instanceof PureScript_CST_Types.TokHole) {

147+ return "?" + v.value0;

148+ };

149+ if (v instanceof PureScript_CST_Types.TokChar) {

150+ return "'" + (v.value0 + "'");

151+ };

152+ if (v instanceof PureScript_CST_Types.TokString) {

153+ return "\"" + (v.value0 + "\"");

154+ };

155+ if (v instanceof PureScript_CST_Types.TokRawString) {

156+ return "\"\"\"" + (v.value0 + "\"\"\"");

157+ };

158+ if (v instanceof PureScript_CST_Types.TokInt) {

159+ return v.value0;

160+ };

161+ if (v instanceof PureScript_CST_Types.TokNumber) {

162+ return v.value0;

163+ };

164+ if (v instanceof PureScript_CST_Types.TokLayoutStart) {

165+ if (option instanceof ShowLayout) {

166+ return "{";

167+ };

168+ if (option instanceof HideLayout) {

169+ return "";

170+ };

171+ throw new Error("Failed pattern match at PureScript.CST.Print (line 111, column 5 - line 113, column 23): " + [ option.constructor.name ]);

172+ };

173+ if (v instanceof PureScript_CST_Types.TokLayoutSep) {

174+ if (option instanceof ShowLayout) {

175+ return ";";

176+ };

177+ if (option instanceof HideLayout) {

178+ return "";

179+ };

180+ throw new Error("Failed pattern match at PureScript.CST.Print (line 115, column 5 - line 117, column 23): " + [ option.constructor.name ]);

181+ };

182+ if (v instanceof PureScript_CST_Types.TokLayoutEnd) {

183+ if (option instanceof ShowLayout) {

184+ return "}";

185+ };

186+ if (option instanceof HideLayout) {

187+ return "";

188+ };

189+ throw new Error("Failed pattern match at PureScript.CST.Print (line 119, column 5 - line 121, column 23): " + [ option.constructor.name ]);

190+ };

191+ throw new Error("Failed pattern match at PureScript.CST.Print (line 37, column 31 - line 121, column 23): " + [ v.constructor.name ]);

192+ };

193+};

194+var printToken = /* #__PURE__ */ (function () {

195+ return printTokenWithOption(HideLayout.value);

196+})();

197+var printLineFeed = function (v) {

198+ if (v instanceof PureScript_CST_Types.LF) {

199+ return "\x0a";

200+ };

201+ if (v instanceof PureScript_CST_Types.CRLF) {

202+ return "\x0d\x0a";

203+ };

204+ throw new Error("Failed pattern match at PureScript.CST.Print (line 135, column 17 - line 137, column 17): " + [ v.constructor.name ]);

205+};

206+var printComment = function (k) {

207+ return function (v) {

208+ if (v instanceof PureScript_CST_Types.Comment) {

209+ return v.value0;

210+ };

211+ if (v instanceof PureScript_CST_Types.Space) {

212+ return power(" ")(v.value0);

213+ };

214+ if (v instanceof PureScript_CST_Types.Line) {

215+ return power(k(v.value0))(v.value1);

216+ };

217+ throw new Error("Failed pattern match at PureScript.CST.Print (line 129, column 18 - line 132, column 28): " + [ v.constructor.name ]);

218+ };

219+};

220+var printSourceTokenWithOption = function (option) {

221+ return function (tok) {

222+ return foldMap(printComment(printLineFeed))(tok.leadingComments) + (printTokenWithOption(option)(tok.value) + foldMap(printComment(Data_Void.absurd))(tok.trailingComments));

223+ };

224+};

225+var printSourceToken = /* #__PURE__ */ (function () {

226+ return printSourceTokenWithOption(HideLayout.value);

227+})();

228+export {

229+ printToken,

230+ printSourceToken,

231+ ShowLayout,

232+ HideLayout,

233+ printTokenWithOption,

234+ printSourceTokenWithOption,

235+ printComment,

236+ printLineFeed,

237+ printQualified

238+};

output-compile-fail/PureScript.CST.Range.TokenList/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Range.TokenList/index.jsnew file+342

@@ -0,0 +1,342 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array from "../Data.Array/index.js";

3+import * as Data_Array_ST from "../Data.Array.ST/index.js";

4+import * as Data_Boolean from "../Data.Boolean/index.js";

5+import * as Data_Maybe from "../Data.Maybe/index.js";

6+import * as Data_Semigroup from "../Data.Semigroup/index.js";

7+import * as Data_Tuple from "../Data.Tuple/index.js";

8+import * as Data_Unfoldable from "../Data.Unfoldable/index.js";

9+import * as Data_Unit from "../Data.Unit/index.js";

10+var unsafeIndex = /* #__PURE__ */ Data_Array.unsafeIndex();

11+var TokenEmpty = /* #__PURE__ */ (function () {

12+ function TokenEmpty() {

13+

14+ };

15+ TokenEmpty.value = new TokenEmpty();

16+ return TokenEmpty;

17+})();

18+var TokenCons = /* #__PURE__ */ (function () {

19+ function TokenCons(value0, value1) {

20+ this.value0 = value0;

21+ this.value1 = value1;

22+ };

23+ TokenCons.create = function (value0) {

24+ return function (value1) {

25+ return new TokenCons(value0, value1);

26+ };

27+ };

28+ return TokenCons;

29+})();

30+var TokenWrap = /* #__PURE__ */ (function () {

31+ function TokenWrap(value0, value1, value2) {

32+ this.value0 = value0;

33+ this.value1 = value1;

34+ this.value2 = value2;

35+ };

36+ TokenWrap.create = function (value0) {

37+ return function (value1) {

38+ return function (value2) {

39+ return new TokenWrap(value0, value1, value2);

40+ };

41+ };

42+ };

43+ return TokenWrap;

44+})();

45+var TokenAppend = /* #__PURE__ */ (function () {

46+ function TokenAppend(value0, value1) {

47+ this.value0 = value0;

48+ this.value1 = value1;

49+ };

50+ TokenAppend.create = function (value0) {

51+ return function (value1) {

52+ return new TokenAppend(value0, value1);

53+ };

54+ };

55+ return TokenAppend;

56+})();

57+var TokenDefer = /* #__PURE__ */ (function () {

58+ function TokenDefer(value0) {

59+ this.value0 = value0;

60+ };

61+ TokenDefer.create = function (value0) {

62+ return new TokenDefer(value0);

63+ };

64+ return TokenDefer;

65+})();

66+var TokenArray = /* #__PURE__ */ (function () {

67+ function TokenArray(value0, value1, value2) {

68+ this.value0 = value0;

69+ this.value1 = value1;

70+ this.value2 = value2;

71+ };

72+ TokenArray.create = function (value0) {

73+ return function (value1) {

74+ return function (value2) {

75+ return new TokenArray(value0, value1, value2);

76+ };

77+ };

78+ };

79+ return TokenArray;

80+})();

81+var UnconsDone = /* #__PURE__ */ (function () {

82+ function UnconsDone() {

83+

84+ };

85+ UnconsDone.value = new UnconsDone();

86+ return UnconsDone;

87+})();

88+var UnconsMore = /* #__PURE__ */ (function () {

89+ function UnconsMore(value0, value1) {

90+ this.value0 = value0;

91+ this.value1 = value1;

92+ };

93+ UnconsMore.create = function (value0) {

94+ return function (value1) {

95+ return new UnconsMore(value0, value1);

96+ };

97+ };

98+ return UnconsMore;

99+})();

100+var wrap = /* #__PURE__ */ (function () {

101+ return TokenWrap.create;

102+})();

103+var singleton = function (a) {

104+ return new TokenCons(a, TokenEmpty.value);

105+};

106+var semigroupTokenList = {

107+ append: function (v) {

108+ return function (v1) {

109+ if (v1 instanceof TokenEmpty) {

110+ return v;

111+ };

112+ if (v instanceof TokenEmpty) {

113+ return v1;

114+ };

115+ return new TokenAppend(v, v1);

116+ };

117+ }

118+};

119+var append = /* #__PURE__ */ Data_Semigroup.append(semigroupTokenList);

120+var uncons2 = function ($copy_done) {

121+ return function ($copy_more) {

122+ return function ($copy_l) {

123+ return function ($copy_r) {

124+ var $tco_var_done = $copy_done;

125+ var $tco_var_more = $copy_more;

126+ var $tco_var_l = $copy_l;

127+ var $tco_done = false;

128+ var $tco_result;

129+ function $tco_loop(done, more, l, r) {

130+ if (l instanceof TokenEmpty) {

131+ $tco_done = true;

132+ return uncons$prime(done)(more)(r);

133+ };

134+ if (l instanceof TokenCons) {

135+ $tco_done = true;

136+ return more(l.value0)(append(l.value1)(r));

137+ };

138+ if (l instanceof TokenWrap) {

139+ $tco_done = true;

140+ return more(l.value0)(append(l.value1)(new TokenCons(l.value2, r)));

141+ };

142+ if (l instanceof TokenAppend) {

143+ $tco_var_done = done;

144+ $tco_var_more = more;

145+ $tco_var_l = l.value0;

146+ $copy_r = append(l.value1)(r);

147+ return;

148+ };

149+ if (l instanceof TokenDefer) {

150+ $tco_var_done = done;

151+ $tco_var_more = more;

152+ $tco_var_l = l.value0(Data_Unit.unit);

153+ $copy_r = r;

154+ return;

155+ };

156+ if (l instanceof TokenArray) {

157+ var next = (function () {

158+ if (l.value0 === l.value1) {

159+ return r;

160+ };

161+ if (Data_Boolean.otherwise) {

162+ return append(new TokenArray(l.value0 + 1 | 0, l.value1, l.value2))(r);

163+ };

164+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 102, column 7 - line 104, column 56): " + [ ]);

165+ })();

166+ $tco_done = true;

167+ return more(unsafeIndex(l.value2)(l.value0))(next);

168+ };

169+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 94, column 25 - line 105, column 52): " + [ l.constructor.name ]);

170+ };

171+ while (!$tco_done) {

172+ $tco_result = $tco_loop($tco_var_done, $tco_var_more, $tco_var_l, $copy_r);

173+ };

174+ return $tco_result;

175+ };

176+ };

177+ };

178+};

179+var uncons$prime = function ($copy_done) {

180+ return function ($copy_more) {

181+ return function ($copy_v) {

182+ var $tco_var_done = $copy_done;

183+ var $tco_var_more = $copy_more;

184+ var $tco_done = false;

185+ var $tco_result;

186+ function $tco_loop(done, more, v) {

187+ if (v instanceof TokenEmpty) {

188+ $tco_done = true;

189+ return done;

190+ };

191+ if (v instanceof TokenCons) {

192+ $tco_done = true;

193+ return more(v.value0)(v.value1);

194+ };

195+ if (v instanceof TokenWrap) {

196+ $tco_done = true;

197+ return more(v.value0)(append(v.value1)(singleton(v.value2)));

198+ };

199+ if (v instanceof TokenAppend) {

200+ $tco_done = true;

201+ return uncons2(done)(more)(v.value0)(v.value1);

202+ };

203+ if (v instanceof TokenDefer) {

204+ $tco_var_done = done;

205+ $tco_var_more = more;

206+ $copy_v = v.value0(Data_Unit.unit);

207+ return;

208+ };

209+ if (v instanceof TokenArray) {

210+ var next = (function () {

211+ if (v.value0 === v.value1) {

212+ return TokenEmpty.value;

213+ };

214+ if (Data_Boolean.otherwise) {

215+ return new TokenArray(v.value0 + 1 | 0, v.value1, v.value2);

216+ };

217+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 88, column 7 - line 90, column 51): " + [ ]);

218+ })();

219+ $tco_done = true;

220+ return more(unsafeIndex(v.value2)(v.value0))(next);

221+ };

222+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 80, column 21 - line 91, column 52): " + [ v.constructor.name ]);

223+ };

224+ while (!$tco_done) {

225+ $tco_result = $tco_loop($tco_var_done, $tco_var_more, $copy_v);

226+ };

227+ return $tco_result;

228+ };

229+ };

230+};

231+var toUnfoldable = function (dictUnfoldable) {

232+ return Data_Unfoldable.unfoldr(dictUnfoldable)(uncons$prime(Data_Maybe.Nothing.value)(function (a) {

233+ return function (b) {

234+ return new Data_Maybe.Just(new Data_Tuple.Tuple(a, b));

235+ };

236+ }));

237+};

238+var uncons = /* #__PURE__ */ (function () {

239+ return uncons$prime(UnconsDone.value)(UnconsMore.create);

240+})();

241+var toArray = function (init) {

242+ return (function __do() {

243+ var arr = Data_Array_ST["new"]();

244+ var cur = init;

245+ var $$continue = true;

246+ (function () {

247+ while ($$continue) {

248+ (function __do() {

249+ var tree = cur;

250+ var v = uncons(tree);

251+ if (v instanceof UnconsDone) {

252+ $$continue = false;

253+ return Data_Unit.unit;

254+ };

255+ if (v instanceof UnconsMore) {

256+ cur = v.value1;

257+ Data_Array_ST.push(v.value0)(arr)();

258+ return Data_Unit.unit;

259+ };

260+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 117, column 5 - line 124, column 18): " + [ v.constructor.name ]);

261+ })();

262+ };

263+ return {};

264+ })();

265+ return Data_Array_ST.unsafeFreeze(arr)();

266+ })();

267+};

268+var monoidTokenList = /* #__PURE__ */ (function () {

269+ return {

270+ mempty: TokenEmpty.value,

271+ Semigroup0: function () {

272+ return semigroupTokenList;

273+ }

274+ };

275+})();

276+var lazyTokenList = /* #__PURE__ */ (function () {

277+ return {

278+ defer: TokenDefer.create

279+ };

280+})();

281+var head = function ($copy_v) {

282+ var $tco_done = false;

283+ var $tco_result;

284+ function $tco_loop(v) {

285+ if (v instanceof TokenEmpty) {

286+ $tco_done = true;

287+ return Data_Maybe.Nothing.value;

288+ };

289+ if (v instanceof TokenCons) {

290+ $tco_done = true;

291+ return new Data_Maybe.Just(v.value0);

292+ };

293+ if (v instanceof TokenDefer) {

294+ $copy_v = v.value0(Data_Unit.unit);

295+ return;

296+ };

297+ if (v instanceof TokenWrap) {

298+ $tco_done = true;

299+ return new Data_Maybe.Just(v.value0);

300+ };

301+ if (v instanceof TokenAppend) {

302+ $copy_v = v.value0;

303+ return;

304+ };

305+ if (v instanceof TokenArray) {

306+ $tco_done = true;

307+ return new Data_Maybe.Just(unsafeIndex(v.value2)(v.value0));

308+ };

309+ throw new Error("Failed pattern match at PureScript.CST.Range.TokenList (line 64, column 8 - line 70, column 67): " + [ v.constructor.name ]);

310+ };

311+ while (!$tco_done) {

312+ $tco_result = $tco_loop($copy_v);

313+ };

314+ return $tco_result;

315+};

316+var fromArray = function (arr) {

317+ var len = Data_Array.length(arr);

318+ var $57 = len === 0;

319+ if ($57) {

320+ return TokenEmpty.value;

321+ };

322+ return new TokenArray(0, len - 1 | 0, arr);

323+};

324+var cons = /* #__PURE__ */ (function () {

325+ return TokenCons.create;

326+})();

327+export {

328+ singleton,

329+ cons,

330+ wrap,

331+ head,

332+ UnconsDone,

333+ UnconsMore,

334+ uncons,

335+ uncons$prime,

336+ toUnfoldable,

337+ toArray,

338+ fromArray,

339+ lazyTokenList,

340+ semigroupTokenList,

341+ monoidTokenList

342+};

output-compile-fail/PureScript.CST.Range/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Range/index.jsnew file+1871

@@ -0,0 +1,1871 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Lazy from "../Control.Lazy/index.js";

3+import * as Data_Array from "../Data.Array/index.js";

4+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

5+import * as Data_Array_NonEmpty_Internal from "../Data.Array.NonEmpty.Internal/index.js";

6+import * as Data_Foldable from "../Data.Foldable/index.js";

7+import * as Data_Maybe from "../Data.Maybe/index.js";

8+import * as Data_Semigroup from "../Data.Semigroup/index.js";

9+import * as Data_Tuple from "../Data.Tuple/index.js";

10+import * as Data_Void from "../Data.Void/index.js";

11+import * as PureScript_CST_Range_TokenList from "../PureScript.CST.Range.TokenList/index.js";

12+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

13+var foldMap = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableArray)(PureScript_CST_Range_TokenList.monoidTokenList);

14+var defer = /* #__PURE__ */ Control_Lazy.defer(PureScript_CST_Range_TokenList.lazyTokenList);

15+var append = /* #__PURE__ */ Data_Semigroup.append(PureScript_CST_Range_TokenList.semigroupTokenList);

16+var foldMap1 = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableMaybe)(PureScript_CST_Range_TokenList.monoidTokenList);

17+var foldMap2 = /* #__PURE__ */ Data_Foldable.foldMap(Data_Array_NonEmpty_Internal.foldableNonEmptyArray)(PureScript_CST_Range_TokenList.monoidTokenList);

18+var tokensOfVoid = {

19+ tokensOf: Data_Void.absurd

20+};

21+var tokensOfRecoveredError = {

22+ tokensOf: function (v) {

23+ return PureScript_CST_Range_TokenList.fromArray(v.tokens);

24+ }

25+};

26+var tokensOfQualifiedName = {

27+ tokensOf: function (v) {

28+ return PureScript_CST_Range_TokenList.singleton(v.token);

29+ }

30+};

31+var tokensOfName = {

32+ tokensOf: function (v) {

33+ return PureScript_CST_Range_TokenList.singleton(v.token);

34+ }

35+};

36+var tokensOf = function (dict) {

37+ return dict.tokensOf;

38+};

39+var tokensOf1 = /* #__PURE__ */ tokensOf(tokensOfQualifiedName);

40+var tokensOf2 = /* #__PURE__ */ tokensOf(tokensOfName);

41+var tokensOfArray = function (dictTokensOf) {

42+ var tokensOf9 = tokensOf(dictTokensOf);

43+ return {

44+ tokensOf: foldMap(function (a) {

45+ return defer(function (v) {

46+ return tokensOf9(a);

47+ });

48+ })

49+ };

50+};

51+var tokensOfFixityOp = {

52+ tokensOf: function (v) {

53+ if (v instanceof PureScript_CST_Types.FixityValue) {

54+ return append(tokensOf1(v.value0))(append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf2(v.value2)));

55+ };

56+ if (v instanceof PureScript_CST_Types.FixityType) {

57+ return PureScript_CST_Range_TokenList.cons(v.value0)(append(tokensOf1(v.value1))(append(PureScript_CST_Range_TokenList.singleton(v.value2))(tokensOf2(v.value3))));

58+ };

59+ throw new Error("Failed pattern match at PureScript.CST.Range (line 643, column 14 - line 647, column 59): " + [ v.constructor.name ]);

60+ }

61+};

62+var tokensOf3 = /* #__PURE__ */ tokensOf(tokensOfFixityOp);

63+var tokensOfLabeled = function (dictTokensOf) {

64+ var tokensOf9 = tokensOf(dictTokensOf);

65+ return function (dictTokensOf1) {

66+ var tokensOf10 = tokensOf(dictTokensOf1);

67+ return {

68+ tokensOf: function (v) {

69+ return append(tokensOf9(v.label))(append(PureScript_CST_Range_TokenList.singleton(v.separator))(tokensOf10(v.value)));

70+ }

71+ };

72+ };

73+};

74+var tokensOfLabeled1 = /* #__PURE__ */ tokensOfLabeled(tokensOfName);

75+var tokensOfMaybe = function (dictTokensOf) {

76+ return {

77+ tokensOf: foldMap1(tokensOf(dictTokensOf))

78+ };

79+};

80+var tokensOfNonEmptyArray = function (dictTokensOf) {

81+ var tokensOf9 = tokensOf(dictTokensOf);

82+ return {

83+ tokensOf: foldMap2(function (a) {

84+ return defer(function (v) {

85+ return tokensOf9(a);

86+ });

87+ })

88+ };

89+};

90+var tokensOf4 = /* #__PURE__ */ tokensOf(/* #__PURE__ */ tokensOfNonEmptyArray(tokensOfName));

91+var tokensOfClassFundep = {

92+ tokensOf: function (v) {

93+ if (v instanceof PureScript_CST_Types.FundepDetermined) {

94+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf4(v.value1));

95+ };

96+ if (v instanceof PureScript_CST_Types.FundepDetermines) {

97+ return append(tokensOf4(v.value0))(append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf4(v.value2)));

98+ };

99+ throw new Error("Failed pattern match at PureScript.CST.Range (line 564, column 14 - line 568, column 50): " + [ v.constructor.name ]);

100+ }

101+};

102+var tokensOfPrefixed = function (dictTokensOf) {

103+ var tokensOf9 = tokensOf(dictTokensOf);

104+ return {

105+ tokensOf: function (v) {

106+ if (v.prefix instanceof Data_Maybe.Just) {

107+ return PureScript_CST_Range_TokenList.cons(v.prefix.value0)(defer(function (v1) {

108+ return tokensOf9(v.value);

109+ }));

110+ };

111+ if (v.prefix instanceof Data_Maybe.Nothing) {

112+ return tokensOf9(v.value);

113+ };

114+ throw new Error("Failed pattern match at PureScript.CST.Range (line 136, column 5 - line 140, column 23): " + [ v.prefix.constructor.name ]);

115+ }

116+ };

117+};

118+var tokensOfPrefixed1 = /* #__PURE__ */ tokensOfPrefixed(tokensOfName);

119+var tokensOfRecordLabeled = function (dictTokensOf) {

120+ var tokensOf9 = tokensOf(dictTokensOf);

121+ return {

122+ tokensOf: function (v) {

123+ if (v instanceof PureScript_CST_Types.RecordPun) {

124+ return tokensOf2(v.value0);

125+ };

126+ if (v instanceof PureScript_CST_Types.RecordField) {

127+ return append(tokensOf2(v.value0))(defer(function (v1) {

128+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf9(v.value2));

129+ }));

130+ };

131+ throw new Error("Failed pattern match at PureScript.CST.Range (line 1012, column 14 - line 1016, column 52): " + [ v.constructor.name ]);

132+ }

133+ };

134+};

135+var tokensOfSeparated = function (dictTokensOf) {

136+ var tokensOf9 = tokensOf(dictTokensOf);

137+ return {

138+ tokensOf: function (v) {

139+ return append(tokensOf9(v.head))(defer(function (v1) {

140+ return foldMap(function (v2) {

141+ return PureScript_CST_Range_TokenList.cons(v2.value0)(defer(function (v3) {

142+ return tokensOf9(v2.value1);

143+ }));

144+ })(v.tail);

145+ }));

146+ }

147+ };

148+};

149+var tokensOfSeparated1 = /* #__PURE__ */ tokensOfSeparated(tokensOfName);

150+var tokensOf5 = /* #__PURE__ */ tokensOf(tokensOfSeparated1);

151+var tokensOf6 = /* #__PURE__ */ tokensOf(/* #__PURE__ */ tokensOfSeparated(tokensOfClassFundep));

152+var tokensOfTuple = function (dictTokensOf) {

153+ var tokensOf9 = tokensOf(dictTokensOf);

154+ return function (dictTokensOf1) {

155+ var tokensOf10 = tokensOf(dictTokensOf1);

156+ return {

157+ tokensOf: function (v) {

158+ return append(tokensOf9(v.value0))(tokensOf10(v.value1));

159+ }

160+ };

161+ };

162+};

163+var tokensOfTuple1 = /* #__PURE__ */ tokensOfTuple(tokensOfQualifiedName);

164+var tokensOfWrapped = function (dictTokensOf) {

165+ var tokensOf9 = tokensOf(dictTokensOf);

166+ return {

167+ tokensOf: function (v) {

168+ return PureScript_CST_Range_TokenList.wrap(v.open)(defer(function (v1) {

169+ return tokensOf9(v.value);

170+ }))(v.close);

171+ }

172+ };

173+};

174+var tokensOf7 = /* #__PURE__ */ tokensOf(/* #__PURE__ */ tokensOfWrapped(/* #__PURE__ */ tokensOfMaybe(tokensOfSeparated1)));

175+var tokensOfDataMembers = {

176+ tokensOf: function (v) {

177+ if (v instanceof PureScript_CST_Types.DataAll) {

178+ return PureScript_CST_Range_TokenList.singleton(v.value0);

179+ };

180+ if (v instanceof PureScript_CST_Types.DataEnumerated) {

181+ return tokensOf7(v.value0);

182+ };

183+ throw new Error("Failed pattern match at PureScript.CST.Range (line 329, column 14 - line 333, column 17): " + [ v.constructor.name ]);

184+ }

185+};

186+var tokensOf8 = /* #__PURE__ */ tokensOf(tokensOfDataMembers);

187+var tokensOfExport = function (dictTokensOf) {

188+ var tokensOf9 = tokensOf(dictTokensOf);

189+ return {

190+ tokensOf: function (v) {

191+ if (v instanceof PureScript_CST_Types.ExportValue) {

192+ return tokensOf2(v.value0);

193+ };

194+ if (v instanceof PureScript_CST_Types.ExportOp) {

195+ return tokensOf2(v.value0);

196+ };

197+ if (v instanceof PureScript_CST_Types.ExportType) {

198+ return append(tokensOf2(v.value0))(foldMap1(tokensOf8)(v.value1));

199+ };

200+ if (v instanceof PureScript_CST_Types.ExportTypeOp) {

201+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

202+ };

203+ if (v instanceof PureScript_CST_Types.ExportClass) {

204+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

205+ };

206+ if (v instanceof PureScript_CST_Types.ExportModule) {

207+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

208+ };

209+ if (v instanceof PureScript_CST_Types.ExportError) {

210+ return tokensOf9(v.value0);

211+ };

212+ throw new Error("Failed pattern match at PureScript.CST.Range (line 305, column 14 - line 319, column 17): " + [ v.constructor.name ]);

213+ }

214+ };

215+};

216+var tokensOfImport = function (dictTokensOf) {

217+ var tokensOf9 = tokensOf(dictTokensOf);

218+ return {

219+ tokensOf: function (v) {

220+ if (v instanceof PureScript_CST_Types.ImportValue) {

221+ return tokensOf2(v.value0);

222+ };

223+ if (v instanceof PureScript_CST_Types.ImportOp) {

224+ return tokensOf2(v.value0);

225+ };

226+ if (v instanceof PureScript_CST_Types.ImportType) {

227+ return append(tokensOf2(v.value0))(foldMap1(tokensOf8)(v.value1));

228+ };

229+ if (v instanceof PureScript_CST_Types.ImportTypeOp) {

230+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

231+ };

232+ if (v instanceof PureScript_CST_Types.ImportClass) {

233+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

234+ };

235+ if (v instanceof PureScript_CST_Types.ImportError) {

236+ return tokensOf9(v.value0);

237+ };

238+ throw new Error("Failed pattern match at PureScript.CST.Range (line 384, column 14 - line 396, column 17): " + [ v.constructor.name ]);

239+ }

240+ };

241+};

242+var tokensOfImportDecl = function (dictTokensOf) {

243+ var tokensOf9 = tokensOf(tokensOfWrapped(tokensOfSeparated(tokensOfImport(dictTokensOf))));

244+ return {

245+ tokensOf: function (v) {

246+ return PureScript_CST_Range_TokenList.cons(v.keyword)(defer(function (v1) {

247+ return append(tokensOf2(v.module))(append(foldMap1(function (v2) {

248+ return append(foldMap1(PureScript_CST_Range_TokenList.singleton)(v2.value0))(defer(function (v3) {

249+ return tokensOf9(v2.value1);

250+ }));

251+ })(v.names))(foldMap1(function (v2) {

252+ return append(PureScript_CST_Range_TokenList.singleton(v2.value0))(tokensOf2(v2.value1));

253+ })(v.qualified)));

254+ }));

255+ }

256+ };

257+};

258+var tokensOfOneOrDelimited = function (dictTokensOf) {

259+ var tokensOf9 = tokensOf(dictTokensOf);

260+ var tokensOf10 = tokensOf(tokensOfWrapped(tokensOfSeparated(dictTokensOf)));

261+ return {

262+ tokensOf: function (v) {

263+ if (v instanceof PureScript_CST_Types.One) {

264+ return tokensOf9(v.value0);

265+ };

266+ if (v instanceof PureScript_CST_Types.Many) {

267+ return tokensOf10(v.value0);

268+ };

269+ throw new Error("Failed pattern match at PureScript.CST.Range (line 148, column 14 - line 150, column 27): " + [ v.constructor.name ]);

270+ }

271+ };

272+};

273+var tokensOfTypeVarBinding = function (dictTokensOf) {

274+ var tokensOfLabeled2 = tokensOfLabeled(dictTokensOf);

275+ var tokensOf9 = tokensOf(dictTokensOf);

276+ return function (dictTokensOf1) {

277+ return {

278+ tokensOf: function (v) {

279+ if (v instanceof PureScript_CST_Types.TypeVarKinded) {

280+ return tokensOf(tokensOfWrapped(tokensOfLabeled2(tokensOfType(dictTokensOf1))))(v.value0);

281+ };

282+ if (v instanceof PureScript_CST_Types.TypeVarName) {

283+ return tokensOf9(v.value0);

284+ };

285+ throw new Error("Failed pattern match at PureScript.CST.Range (line 269, column 14 - line 273, column 17): " + [ v.constructor.name ]);

286+ }

287+ };

288+ };

289+};

290+var tokensOfType = function (dictTokensOf) {

291+ var tokensOf9 = tokensOf(dictTokensOf);

292+ return {

293+ tokensOf: function (v) {

294+ if (v instanceof PureScript_CST_Types.TypeVar) {

295+ return tokensOf2(v.value0);

296+ };

297+ if (v instanceof PureScript_CST_Types.TypeConstructor) {

298+ return tokensOf1(v.value0);

299+ };

300+ if (v instanceof PureScript_CST_Types.TypeWildcard) {

301+ return PureScript_CST_Range_TokenList.singleton(v.value0);

302+ };

303+ if (v instanceof PureScript_CST_Types.TypeHole) {

304+ return tokensOf2(v.value0);

305+ };

306+ if (v instanceof PureScript_CST_Types.TypeString) {

307+ return PureScript_CST_Range_TokenList.singleton(v.value0);

308+ };

309+ if (v instanceof PureScript_CST_Types.TypeInt) {

310+ return append(foldMap1(PureScript_CST_Range_TokenList.singleton)(v.value0))(PureScript_CST_Range_TokenList.singleton(v.value1));

311+ };

312+ if (v instanceof PureScript_CST_Types.TypeRow) {

313+ return tokensOf(tokensOfWrapped(tokensOfRow(dictTokensOf)))(v.value0);

314+ };

315+ if (v instanceof PureScript_CST_Types.TypeRecord) {

316+ return tokensOf(tokensOfWrapped(tokensOfRow(dictTokensOf)))(v.value0);

317+ };

318+ if (v instanceof PureScript_CST_Types.TypeForall) {

319+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

320+ return append(tokensOf(tokensOfNonEmptyArray(tokensOfTypeVarBinding(tokensOfPrefixed1)(dictTokensOf)))(v.value1))(append(PureScript_CST_Range_TokenList.singleton(v.value2))(tokensOf(tokensOfType(dictTokensOf))(v.value3)));

321+ }));

322+ };

323+ if (v instanceof PureScript_CST_Types.TypeKinded) {

324+ return append(tokensOf(tokensOfType(dictTokensOf))(v.value0))(defer(function (v1) {

325+ return append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf(tokensOfType(dictTokensOf))(v.value2));

326+ }));

327+ };

328+ if (v instanceof PureScript_CST_Types.TypeApp) {

329+ return append(tokensOf(tokensOfType(dictTokensOf))(v.value0))(defer(function (v1) {

330+ return tokensOf(tokensOfNonEmptyArray(tokensOfType(dictTokensOf)))(v.value1);

331+ }));

332+ };

333+ if (v instanceof PureScript_CST_Types.TypeOp) {

334+ return append(tokensOf(tokensOfType(dictTokensOf))(v.value0))(defer(function (v1) {

335+ return foldMap2(function (v2) {

336+ return append(tokensOf1(v2.value0))(tokensOf(tokensOfType(dictTokensOf))(v2.value1));

337+ })(v.value1);

338+ }));

339+ };

340+ if (v instanceof PureScript_CST_Types.TypeOpName) {

341+ return tokensOf1(v.value0);

342+ };

343+ if (v instanceof PureScript_CST_Types.TypeArrow) {

344+ return append(tokensOf(tokensOfType(dictTokensOf))(v.value0))(defer(function (v1) {

345+ return append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf(tokensOfType(dictTokensOf))(v.value2));

346+ }));

347+ };

348+ if (v instanceof PureScript_CST_Types.TypeArrowName) {

349+ return PureScript_CST_Range_TokenList.singleton(v.value0);

350+ };

351+ if (v instanceof PureScript_CST_Types.TypeConstrained) {

352+ return append(tokensOf(tokensOfType(dictTokensOf))(v.value0))(defer(function (v1) {

353+ return append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf(tokensOfType(dictTokensOf))(v.value2));

354+ }));

355+ };

356+ if (v instanceof PureScript_CST_Types.TypeParens) {

357+ return tokensOf(tokensOfWrapped(tokensOfType(dictTokensOf)))(v.value0);

358+ };

359+ if (v instanceof PureScript_CST_Types["TypeError"]) {

360+ return tokensOf9(v.value0);

361+ };

362+ throw new Error("Failed pattern match at PureScript.CST.Range (line 210, column 14 - line 254, column 17): " + [ v.constructor.name ]);

363+ }

364+ };

365+};

366+var tokensOfRow = function (dictTokensOf) {

367+ return {

368+ tokensOf: function (v) {

369+ return append(foldMap1(tokensOf(tokensOfSeparated(tokensOfLabeled1(tokensOfType(dictTokensOf)))))(v.labels))(foldMap1(function (v1) {

370+ return PureScript_CST_Range_TokenList.cons(v1.value0)(tokensOf(tokensOfType(dictTokensOf))(v1.value1));

371+ })(v.tail));

372+ }

373+ };

374+};

375+var tokensOfTypeVarBinding1 = /* #__PURE__ */ tokensOfTypeVarBinding(tokensOfName);

376+var tokensOfAppSpine = function (dictTokensOf) {

377+ var tokensOf9 = tokensOf(tokensOfType(dictTokensOf));

378+ return function (dictTokensOf1) {

379+ var tokensOf10 = tokensOf(dictTokensOf1);

380+ return {

381+ tokensOf: function (v) {

382+ if (v instanceof PureScript_CST_Types.AppType) {

383+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

384+ return tokensOf9(v.value1);

385+ }));

386+ };

387+ if (v instanceof PureScript_CST_Types.AppTerm) {

388+ return tokensOf10(v.value0);

389+ };

390+ throw new Error("Failed pattern match at PureScript.CST.Range (line 856, column 14 - line 860, column 17): " + [ v.constructor.name ]);

391+ }

392+ };

393+ };

394+};

395+var tokensOfBinder = function (dictTokensOf) {

396+ var tokensOf9 = tokensOf(tokensOfType(dictTokensOf));

397+ var tokensOf10 = tokensOf(dictTokensOf);

398+ return {

399+ tokensOf: function (v) {

400+ if (v instanceof PureScript_CST_Types.BinderWildcard) {

401+ return PureScript_CST_Range_TokenList.singleton(v.value0);

402+ };

403+ if (v instanceof PureScript_CST_Types.BinderVar) {

404+ return tokensOf2(v.value0);

405+ };

406+ if (v instanceof PureScript_CST_Types.BinderNamed) {

407+ return append(tokensOf2(v.value0))(defer(function (v1) {

408+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf(tokensOfBinder(dictTokensOf))(v.value2));

409+ }));

410+ };

411+ if (v instanceof PureScript_CST_Types.BinderConstructor) {

412+ return append(tokensOf1(v.value0))(defer(function (v1) {

413+ return tokensOf(tokensOfArray(tokensOfBinder(dictTokensOf)))(v.value1);

414+ }));

415+ };

416+ if (v instanceof PureScript_CST_Types.BinderBoolean) {

417+ return PureScript_CST_Range_TokenList.singleton(v.value0);

418+ };

419+ if (v instanceof PureScript_CST_Types.BinderChar) {

420+ return PureScript_CST_Range_TokenList.singleton(v.value0);

421+ };

422+ if (v instanceof PureScript_CST_Types.BinderString) {

423+ return PureScript_CST_Range_TokenList.singleton(v.value0);

424+ };

425+ if (v instanceof PureScript_CST_Types.BinderInt) {

426+ return append(foldMap1(PureScript_CST_Range_TokenList.singleton)(v.value0))(PureScript_CST_Range_TokenList.singleton(v.value1));

427+ };

428+ if (v instanceof PureScript_CST_Types.BinderNumber) {

429+ return append(foldMap1(PureScript_CST_Range_TokenList.singleton)(v.value0))(PureScript_CST_Range_TokenList.singleton(v.value1));

430+ };

431+ if (v instanceof PureScript_CST_Types.BinderArray) {

432+ return tokensOf(tokensOfWrapped(tokensOfMaybe(tokensOfSeparated(tokensOfBinder(dictTokensOf)))))(v.value0);

433+ };

434+ if (v instanceof PureScript_CST_Types.BinderRecord) {

435+ return tokensOf(tokensOfWrapped(tokensOfMaybe(tokensOfSeparated(tokensOfRecordLabeled(tokensOfBinder(dictTokensOf))))))(v.value0);

436+ };

437+ if (v instanceof PureScript_CST_Types.BinderParens) {

438+ return tokensOf(tokensOfWrapped(tokensOfBinder(dictTokensOf)))(v.value0);

439+ };

440+ if (v instanceof PureScript_CST_Types.BinderTyped) {

441+ return append(tokensOf(tokensOfBinder(dictTokensOf))(v.value0))(defer(function (v1) {

442+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf9(v.value2));

443+ }));

444+ };

445+ if (v instanceof PureScript_CST_Types.BinderOp) {

446+ return append(tokensOf(tokensOfBinder(dictTokensOf))(v.value0))(defer(function (v1) {

447+ return tokensOf(tokensOfNonEmptyArray(tokensOfTuple1(tokensOfBinder(dictTokensOf))))(v.value1);

448+ }));

449+ };

450+ if (v instanceof PureScript_CST_Types.BinderError) {

451+ return tokensOf10(v.value0);

452+ };

453+ throw new Error("Failed pattern match at PureScript.CST.Range (line 979, column 14 - line 1009, column 17): " + [ v.constructor.name ]);

454+ }

455+ };

456+};

457+var tokensOfDataCtor = function (dictTokensOf) {

458+ var tokensOf9 = tokensOf(tokensOfArray(tokensOfType(dictTokensOf)));

459+ return {

460+ tokensOf: function (v) {

461+ return append(tokensOf2(v.name))(tokensOf9(v.fields));

462+ }

463+ };

464+};

465+var tokensOfForeign = function (dictTokensOf) {

466+ var tokensOf9 = tokensOf(tokensOfLabeled1(tokensOfType(dictTokensOf)));

467+ return {

468+ tokensOf: function (v) {

469+ if (v instanceof PureScript_CST_Types.ForeignValue) {

470+ return tokensOf9(v.value0);

471+ };

472+ if (v instanceof PureScript_CST_Types.ForeignData) {

473+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf9(v.value1));

474+ };

475+ if (v instanceof PureScript_CST_Types.ForeignKind) {

476+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf2(v.value1));

477+ };

478+ throw new Error("Failed pattern match at PureScript.CST.Range (line 663, column 14 - line 669, column 26): " + [ v.constructor.name ]);

479+ }

480+ };

481+};

482+var tokensOfWhere = function (dictTokensOf) {

483+ return {

484+ tokensOf: function (v) {

485+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.expr))(defer(function (v1) {

486+ return foldMap1(function (v2) {

487+ return PureScript_CST_Range_TokenList.cons(v2.value0)(tokensOf(tokensOfNonEmptyArray(tokensOfLetBinding(dictTokensOf)))(v2.value1));

488+ })(v.bindings);

489+ }));

490+ }

491+ };

492+};

493+var tokensOfRecordUpdate = function (dictTokensOf) {

494+ return {

495+ tokensOf: function (v) {

496+ if (v instanceof PureScript_CST_Types.RecordUpdateLeaf) {

497+ return append(tokensOf2(v.value0))(append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf(tokensOfExpr(dictTokensOf))(v.value2)));

498+ };

499+ if (v instanceof PureScript_CST_Types.RecordUpdateBranch) {

500+ return append(tokensOf2(v.value0))(tokensOf(tokensOfWrapped(tokensOfSeparated(tokensOfRecordUpdate(dictTokensOf))))(v.value1));

501+ };

502+ throw new Error("Failed pattern match at PureScript.CST.Range (line 863, column 14 - line 867, column 32): " + [ v.constructor.name ]);

503+ }

504+ };

505+};

506+var tokensOfPatternGuard = function (dictTokensOf) {

507+ var tokensOf9 = tokensOf(tokensOfBinder(dictTokensOf));

508+ return {

509+ tokensOf: function (v) {

510+ return append(foldMap1(function (v1) {

511+ return append(tokensOf9(v1.value0))(PureScript_CST_Range_TokenList.singleton(v1.value1));

512+ })(v.binder))(tokensOf(tokensOfExpr(dictTokensOf))(v.expr));

513+ }

514+ };

515+};

516+var tokensOfLetBinding = function (dictTokensOf) {

517+ var tokensOf9 = tokensOf(tokensOfLabeled1(tokensOfType(dictTokensOf)));

518+ var tokensOfBinder1 = tokensOfBinder(dictTokensOf);

519+ var tokensOf10 = tokensOf(tokensOfArray(tokensOfBinder1));

520+ var tokensOf11 = tokensOf(tokensOfBinder1);

521+ var tokensOf12 = tokensOf(dictTokensOf);

522+ return {

523+ tokensOf: function (v) {

524+ if (v instanceof PureScript_CST_Types.LetBindingSignature) {

525+ return tokensOf9(v.value0);

526+ };

527+ if (v instanceof PureScript_CST_Types.LetBindingName) {

528+ return append(tokensOf2(v.value0.name))(defer(function (v1) {

529+ return append(tokensOf10(v.value0.binders))(tokensOf(tokensOfGuarded(dictTokensOf))(v.value0.guarded));

530+ }));

531+ };

532+ if (v instanceof PureScript_CST_Types.LetBindingPattern) {

533+ return append(tokensOf11(v.value0))(defer(function (v1) {

534+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf(tokensOfWhere(dictTokensOf))(v.value2));

535+ }));

536+ };

537+ if (v instanceof PureScript_CST_Types.LetBindingError) {

538+ return tokensOf12(v.value0);

539+ };

540+ throw new Error("Failed pattern match at PureScript.CST.Range (line 911, column 14 - line 919, column 17): " + [ v.constructor.name ]);

541+ }

542+ };

543+};

544+var tokensOfGuardedExpr = function (dictTokensOf) {

545+ return {

546+ tokensOf: function (v) {

547+ return PureScript_CST_Range_TokenList.cons(v.bar)(defer(function (v1) {

548+ return append(tokensOf(tokensOfSeparated(tokensOfPatternGuard(dictTokensOf)))(v.patterns))(append(PureScript_CST_Range_TokenList.singleton(v.separator))(tokensOf(tokensOfWhere(dictTokensOf))(v.where)));

549+ }));

550+ }

551+ };

552+};

553+var tokensOfGuarded = function (dictTokensOf) {

554+ return {

555+ tokensOf: function (v) {

556+ if (v instanceof PureScript_CST_Types.Unconditional) {

557+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf(tokensOfWhere(dictTokensOf))(v.value1));

558+ };

559+ if (v instanceof PureScript_CST_Types.Guarded) {

560+ return tokensOf(tokensOfNonEmptyArray(tokensOfGuardedExpr(dictTokensOf)))(v.value0);

561+ };

562+ throw new Error("Failed pattern match at PureScript.CST.Range (line 607, column 14 - line 611, column 18): " + [ v.constructor.name ]);

563+ }

564+ };

565+};

566+var tokensOfExpr = function (dictTokensOf) {

567+ var tokensOf9 = tokensOf(tokensOfType(dictTokensOf));

568+ var tokensOfAppSpine1 = tokensOfAppSpine(dictTokensOf);

569+ var tokensOfBinder1 = tokensOfBinder(dictTokensOf);

570+ var tokensOf10 = tokensOf(tokensOfNonEmptyArray(tokensOfBinder1));

571+ var tokensOfTuple2 = tokensOfTuple(tokensOfSeparated(tokensOfBinder1));

572+ var tokensOf11 = tokensOf(dictTokensOf);

573+ return {

574+ tokensOf: function (v) {

575+ if (v instanceof PureScript_CST_Types.ExprHole) {

576+ return tokensOf2(v.value0);

577+ };

578+ if (v instanceof PureScript_CST_Types.ExprSection) {

579+ return PureScript_CST_Range_TokenList.singleton(v.value0);

580+ };

581+ if (v instanceof PureScript_CST_Types.ExprIdent) {

582+ return tokensOf1(v.value0);

583+ };

584+ if (v instanceof PureScript_CST_Types.ExprConstructor) {

585+ return tokensOf1(v.value0);

586+ };

587+ if (v instanceof PureScript_CST_Types.ExprBoolean) {

588+ return PureScript_CST_Range_TokenList.singleton(v.value0);

589+ };

590+ if (v instanceof PureScript_CST_Types.ExprChar) {

591+ return PureScript_CST_Range_TokenList.singleton(v.value0);

592+ };

593+ if (v instanceof PureScript_CST_Types.ExprString) {

594+ return PureScript_CST_Range_TokenList.singleton(v.value0);

595+ };

596+ if (v instanceof PureScript_CST_Types.ExprInt) {

597+ return PureScript_CST_Range_TokenList.singleton(v.value0);

598+ };

599+ if (v instanceof PureScript_CST_Types.ExprNumber) {

600+ return PureScript_CST_Range_TokenList.singleton(v.value0);

601+ };

602+ if (v instanceof PureScript_CST_Types.ExprArray) {

603+ return tokensOf(tokensOfWrapped(tokensOfMaybe(tokensOfSeparated(tokensOfExpr(dictTokensOf)))))(v.value0);

604+ };

605+ if (v instanceof PureScript_CST_Types.ExprRecord) {

606+ return tokensOf(tokensOfWrapped(tokensOfMaybe(tokensOfSeparated(tokensOfRecordLabeled(tokensOfExpr(dictTokensOf))))))(v.value0);

607+ };

608+ if (v instanceof PureScript_CST_Types.ExprParens) {

609+ return tokensOf(tokensOfWrapped(tokensOfExpr(dictTokensOf)))(v.value0);

610+ };

611+ if (v instanceof PureScript_CST_Types.ExprTyped) {

612+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0))(defer(function (v1) {

613+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf9(v.value2));

614+ }));

615+ };

616+ if (v instanceof PureScript_CST_Types.ExprInfix) {

617+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0))(defer(function (v1) {

618+ return tokensOf(tokensOfNonEmptyArray(tokensOfTuple(tokensOfWrapped(tokensOfExpr(dictTokensOf)))(tokensOfExpr(dictTokensOf))))(v.value1);

619+ }));

620+ };

621+ if (v instanceof PureScript_CST_Types.ExprOp) {

622+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0))(defer(function (v1) {

623+ return tokensOf(tokensOfNonEmptyArray(tokensOfTuple1(tokensOfExpr(dictTokensOf))))(v.value1);

624+ }));

625+ };

626+ if (v instanceof PureScript_CST_Types.ExprOpName) {

627+ return tokensOf1(v.value0);

628+ };

629+ if (v instanceof PureScript_CST_Types.ExprNegate) {

630+ return PureScript_CST_Range_TokenList.cons(v.value0)(tokensOf(tokensOfExpr(dictTokensOf))(v.value1));

631+ };

632+ if (v instanceof PureScript_CST_Types.ExprRecordAccessor) {

633+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0.expr))(defer(function (v1) {

634+ return PureScript_CST_Range_TokenList.cons(v.value0.dot)(tokensOf5(v.value0.path));

635+ }));

636+ };

637+ if (v instanceof PureScript_CST_Types.ExprRecordUpdate) {

638+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0))(defer(function (v1) {

639+ return tokensOf(tokensOfWrapped(tokensOfSeparated(tokensOfRecordUpdate(dictTokensOf))))(v.value1);

640+ }));

641+ };

642+ if (v instanceof PureScript_CST_Types.ExprApp) {

643+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0))(defer(function (v1) {

644+ return tokensOf(tokensOfNonEmptyArray(tokensOfAppSpine1(tokensOfExpr(dictTokensOf))))(v.value1);

645+ }));

646+ };

647+ if (v instanceof PureScript_CST_Types.ExprLambda) {

648+ return PureScript_CST_Range_TokenList.cons(v.value0.symbol)(defer(function (v1) {

649+ return append(tokensOf10(v.value0.binders))(append(PureScript_CST_Range_TokenList.singleton(v.value0.arrow))(tokensOf(tokensOfExpr(dictTokensOf))(v.value0.body)));

650+ }));

651+ };

652+ if (v instanceof PureScript_CST_Types.ExprIf) {

653+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

654+ return append(tokensOf(tokensOfExpr(dictTokensOf))(v.value0.cond))(append(PureScript_CST_Range_TokenList.singleton(v.value0.then))(append(tokensOf(tokensOfExpr(dictTokensOf))(v["value0"]["true"]))(append(PureScript_CST_Range_TokenList.singleton(v["value0"]["else"]))(tokensOf(tokensOfExpr(dictTokensOf))(v["value0"]["false"])))));

655+ }));

656+ };

657+ if (v instanceof PureScript_CST_Types.ExprCase) {

658+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

659+ return append(tokensOf(tokensOfSeparated(tokensOfExpr(dictTokensOf)))(v.value0.head))(append(PureScript_CST_Range_TokenList.singleton(v.value0.of))(tokensOf(tokensOfNonEmptyArray(tokensOfTuple2(tokensOfGuarded(dictTokensOf))))(v.value0.branches)));

660+ }));

661+ };

662+ if (v instanceof PureScript_CST_Types.ExprLet) {

663+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

664+ return append(tokensOf(tokensOfNonEmptyArray(tokensOfLetBinding(dictTokensOf)))(v.value0.bindings))(append(PureScript_CST_Range_TokenList.singleton(v["value0"]["in"]))(tokensOf(tokensOfExpr(dictTokensOf))(v.value0.body)));

665+ }));

666+ };

667+ if (v instanceof PureScript_CST_Types.ExprDo) {

668+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

669+ return tokensOf(tokensOfNonEmptyArray(tokensOfDoStatement(dictTokensOf)))(v.value0.statements);

670+ }));

671+ };

672+ if (v instanceof PureScript_CST_Types.ExprAdo) {

673+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

674+ return append(tokensOf(tokensOfArray(tokensOfDoStatement(dictTokensOf)))(v.value0.statements))(append(PureScript_CST_Range_TokenList.singleton(v["value0"]["in"]))(tokensOf(tokensOfExpr(dictTokensOf))(v.value0.result)));

675+ }));

676+ };

677+ if (v instanceof PureScript_CST_Types.ExprError) {

678+ return tokensOf11(v.value0);

679+ };

680+ throw new Error("Failed pattern match at PureScript.CST.Range (line 773, column 14 - line 844, column 17): " + [ v.constructor.name ]);

681+ }

682+ };

683+};

684+var tokensOfDoStatement = function (dictTokensOf) {

685+ var tokensOf9 = tokensOf(tokensOfBinder(dictTokensOf));

686+ var tokensOf10 = tokensOf(dictTokensOf);

687+ return {

688+ tokensOf: function (v) {

689+ if (v instanceof PureScript_CST_Types.DoLet) {

690+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

691+ return tokensOf(tokensOfNonEmptyArray(tokensOfLetBinding(dictTokensOf)))(v.value1);

692+ }));

693+ };

694+ if (v instanceof PureScript_CST_Types.DoDiscard) {

695+ return tokensOf(tokensOfExpr(dictTokensOf))(v.value0);

696+ };

697+ if (v instanceof PureScript_CST_Types.DoBind) {

698+ return append(tokensOf9(v.value0))(defer(function (v1) {

699+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf(tokensOfExpr(dictTokensOf))(v.value2));

700+ }));

701+ };

702+ if (v instanceof PureScript_CST_Types.DoError) {

703+ return tokensOf10(v.value0);

704+ };

705+ throw new Error("Failed pattern match at PureScript.CST.Range (line 885, column 14 - line 893, column 17): " + [ v.constructor.name ]);

706+ }

707+ };

708+};

709+var tokensOfInstanceBinding = function (dictTokensOf) {

710+ var tokensOf9 = tokensOf(tokensOfLabeled1(tokensOfType(dictTokensOf)));

711+ var tokensOf10 = tokensOf(tokensOfArray(tokensOfBinder(dictTokensOf)));

712+ var tokensOf11 = tokensOf(tokensOfGuarded(dictTokensOf));

713+ return {

714+ tokensOf: function (v) {

715+ if (v instanceof PureScript_CST_Types.InstanceBindingSignature) {

716+ return tokensOf9(v.value0);

717+ };

718+ if (v instanceof PureScript_CST_Types.InstanceBindingName) {

719+ return append(tokensOf2(v.value0.name))(append(tokensOf10(v.value0.binders))(tokensOf11(v.value0.guarded)));

720+ };

721+ throw new Error("Failed pattern match at PureScript.CST.Range (line 681, column 14 - line 687, column 28): " + [ v.constructor.name ]);

722+ }

723+ };

724+};

725+var tokensOfInstance = function (dictTokensOf) {

726+ var tokensOfType1 = tokensOfType(dictTokensOf);

727+ var tokensOf9 = tokensOf(tokensOfOneOrDelimited(tokensOfType1));

728+ var tokensOf10 = tokensOf(tokensOfArray(tokensOfType1));

729+ var tokensOf11 = tokensOf(tokensOfNonEmptyArray(tokensOfInstanceBinding(dictTokensOf)));

730+ return {

731+ tokensOf: function (v) {

732+ return PureScript_CST_Range_TokenList.cons(v.head.keyword)(defer(function (v1) {

733+ return append(foldMap1(function (v2) {

734+ return append(tokensOf2(v2.value0))(PureScript_CST_Range_TokenList.singleton(v2.value1));

735+ })(v.head.name))(append(foldMap1(function (v2) {

736+ return append(tokensOf9(v2.value0))(PureScript_CST_Range_TokenList.singleton(v2.value1));

737+ })(v.head.constraints))(append(tokensOf1(v.head.className))(append(tokensOf10(v.head.types))(foldMap1(function (v2) {

738+ return PureScript_CST_Range_TokenList.cons(v2.value0)(tokensOf11(v2.value1));

739+ })(v.body)))));

740+ }));

741+ }

742+ };

743+};

744+var tokensOfDecl = function (dictTokensOf) {

745+ var tokensOf9 = tokensOf(tokensOfArray(tokensOfTypeVarBinding1(dictTokensOf)));

746+ var tokensOf10 = tokensOf(tokensOfSeparated(tokensOfDataCtor(dictTokensOf)));

747+ var tokensOfType1 = tokensOfType(dictTokensOf);

748+ var tokensOf11 = tokensOf(tokensOfType1);

749+ var tokensOf12 = tokensOf(tokensOfOneOrDelimited(tokensOfType1));

750+ var tokensOfLabeled2 = tokensOfLabeled1(tokensOfType1);

751+ var tokensOf13 = tokensOf(tokensOfNonEmptyArray(tokensOfLabeled2));

752+ var tokensOf14 = tokensOf(tokensOfSeparated(tokensOfInstance(dictTokensOf)));

753+ var tokensOf15 = tokensOf(tokensOfArray(tokensOfType1));

754+ var tokensOf16 = tokensOf(tokensOfLabeled2);

755+ var tokensOf17 = tokensOf(tokensOfArray(tokensOfBinder(dictTokensOf)));

756+ var tokensOf18 = tokensOf(tokensOfGuarded(dictTokensOf));

757+ var tokensOf19 = tokensOf(tokensOfForeign(dictTokensOf));

758+ var tokensOf20 = tokensOf(dictTokensOf);

759+ return {

760+ tokensOf: function (v) {

761+ if (v instanceof PureScript_CST_Types.DeclData) {

762+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

763+ return append(tokensOf2(v.value0.name))(append(tokensOf9(v.value0.vars))(foldMap1(function (v2) {

764+ return PureScript_CST_Range_TokenList.cons(v2.value0)(tokensOf10(v2.value1));

765+ })(v.value1)));

766+ }));

767+ };

768+ if (v instanceof PureScript_CST_Types.DeclType) {

769+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

770+ return append(tokensOf2(v.value0.name))(append(tokensOf9(v.value0.vars))(append(PureScript_CST_Range_TokenList.singleton(v.value1))(tokensOf11(v.value2))));

771+ }));

772+ };

773+ if (v instanceof PureScript_CST_Types.DeclNewtype) {

774+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

775+ return append(tokensOf2(v.value0.name))(append(tokensOf9(v.value0.vars))(append(PureScript_CST_Range_TokenList.singleton(v.value1))(append(tokensOf2(v.value2))(tokensOf11(v.value3)))));

776+ }));

777+ };

778+ if (v instanceof PureScript_CST_Types.DeclClass) {

779+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword)(defer(function (v1) {

780+ return append(foldMap1(function (v2) {

781+ return append(tokensOf12(v2.value0))(PureScript_CST_Range_TokenList.singleton(v2.value1));

782+ })(v["value0"]["super"]))(append(tokensOf2(v.value0.name))(append(tokensOf9(v.value0.vars))(append(foldMap1(function (v2) {

783+ return PureScript_CST_Range_TokenList.cons(v2.value0)(tokensOf6(v2.value1));

784+ })(v.value0.fundeps))(foldMap1(function (v2) {

785+ return PureScript_CST_Range_TokenList.cons(v2.value0)(tokensOf13(v2.value1));

786+ })(v.value1)))));

787+ }));

788+ };

789+ if (v instanceof PureScript_CST_Types.DeclInstanceChain) {

790+ return tokensOf14(v.value0);

791+ };

792+ if (v instanceof PureScript_CST_Types.DeclDerive) {

793+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

794+ return append(foldMap1(PureScript_CST_Range_TokenList.singleton)(v.value1))(append(PureScript_CST_Range_TokenList.singleton(v.value2.keyword))(append(foldMap1(function (v2) {

795+ return append(tokensOf2(v2.value0))(PureScript_CST_Range_TokenList.singleton(v2.value1));

796+ })(v.value2.name))(append(foldMap1(function (v2) {

797+ return append(tokensOf12(v2.value0))(PureScript_CST_Range_TokenList.singleton(v2.value1));

798+ })(v.value2.constraints))(append(tokensOf1(v.value2.className))(tokensOf15(v.value2.types))))));

799+ }));

800+ };

801+ if (v instanceof PureScript_CST_Types.DeclKindSignature) {

802+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

803+ return tokensOf16(v.value1);

804+ }));

805+ };

806+ if (v instanceof PureScript_CST_Types.DeclSignature) {

807+ return tokensOf16(v.value0);

808+ };

809+ if (v instanceof PureScript_CST_Types.DeclValue) {

810+ return append(tokensOf2(v.value0.name))(defer(function (v1) {

811+ return append(tokensOf17(v.value0.binders))(tokensOf18(v.value0.guarded));

812+ }));

813+ };

814+ if (v instanceof PureScript_CST_Types.DeclFixity) {

815+ return PureScript_CST_Range_TokenList.cons(v.value0.keyword.value0)(defer(function (v1) {

816+ return PureScript_CST_Range_TokenList.cons(v.value0.prec.value0)(tokensOf3(v.value0.operator));

817+ }));

818+ };

819+ if (v instanceof PureScript_CST_Types.DeclForeign) {

820+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

821+ return PureScript_CST_Range_TokenList.cons(v.value1)(tokensOf19(v.value2));

822+ }));

823+ };

824+ if (v instanceof PureScript_CST_Types.DeclRole) {

825+ return PureScript_CST_Range_TokenList.cons(v.value0)(defer(function (v1) {

826+ return append(PureScript_CST_Range_TokenList.singleton(v.value1))(append(tokensOf2(v.value2))(foldMap2(function (v2) {

827+ return PureScript_CST_Range_TokenList.singleton(v2.value0);

828+ })(v.value3)));

829+ }));

830+ };

831+ if (v instanceof PureScript_CST_Types.DeclError) {

832+ return tokensOf20(v.value0);

833+ };

834+ throw new Error("Failed pattern match at PureScript.CST.Range (line 494, column 14 - line 550, column 17): " + [ v.constructor.name ]);

835+ }

836+ };

837+};

838+var tokensOfModule = function (dictTokensOf) {

839+ var tokensOf9 = tokensOf(tokensOfWrapped(tokensOfSeparated(tokensOfExport(dictTokensOf))));

840+ var tokensOf10 = tokensOf(tokensOfImportDecl(dictTokensOf));

841+ var tokensOf11 = tokensOf(tokensOfDecl(dictTokensOf));

842+ return {

843+ tokensOf: function (v) {

844+ return PureScript_CST_Range_TokenList.cons(v.header.keyword)(append(tokensOf2(v.header.name))(append(defer(function (v1) {

845+ return foldMap1(tokensOf9)(v.header.exports);

846+ }))(append(PureScript_CST_Range_TokenList.singleton(v.header.where))(append(defer(function (v1) {

847+ return foldMap(tokensOf10)(v.header.imports);

848+ }))(defer(function (v1) {

849+ return foldMap(tokensOf11)(v.body.decls);

850+ }))))));

851+ }

852+ };

853+};

854+var rangeOfWrapped = {

855+ rangeOf: function (v) {

856+ return {

857+ start: v.open.range.start,

858+ end: v.close.range.end

859+ };

860+ }

861+};

862+var rangeOfVoid = {

863+ rangeOf: Data_Void.absurd

864+};

865+var rangeOfRecoveredError = {

866+ rangeOf: function (v) {

867+ var v1 = Data_Array_NonEmpty.fromArray(v.tokens);

868+ if (v1 instanceof Data_Maybe.Just) {

869+ return {

870+ start: (Data_Array_NonEmpty.head(v1.value0)).range.start,

871+ end: (Data_Array_NonEmpty.last(v1.value0)).range.end

872+ };

873+ };

874+ if (v1 instanceof Data_Maybe.Nothing) {

875+ return {

876+ start: v.position,

877+ end: v.position

878+ };

879+ };

880+ throw new Error("Failed pattern match at PureScript.CST.Range (line 49, column 5 - line 57, column 10): " + [ v1.constructor.name ]);

881+ }

882+};

883+var rangeOfQualifiedName = {

884+ rangeOf: function (v) {

885+ return v.token.range;

886+ }

887+};

888+var rangeOfName = {

889+ rangeOf: function (v) {

890+ return v.token.range;

891+ }

892+};

893+var rangeOfModule = {

894+ rangeOf: function (v) {

895+ return {

896+ start: v.header.keyword.range.start,

897+ end: v.body.end

898+ };

899+ }

900+};

901+var rangeOf = function (dict) {

902+ return dict.rangeOf;

903+};

904+var rangeOf1 = /* #__PURE__ */ rangeOf(rangeOfName);

905+var rangeOf2 = /* #__PURE__ */ rangeOf(rangeOfWrapped);

906+var rangeOf3 = /* #__PURE__ */ rangeOf(rangeOfQualifiedName);

907+var rangeOfClassFundep = {

908+ rangeOf: function (v) {

909+ if (v instanceof PureScript_CST_Types.FundepDetermined) {

910+ return {

911+ start: v.value0.range.start,

912+ end: (rangeOf1(Data_Array_NonEmpty.last(v.value1))).end

913+ };

914+ };

915+ if (v instanceof PureScript_CST_Types.FundepDetermines) {

916+ return {

917+ start: (rangeOf1(Data_Array_NonEmpty.head(v.value0))).start,

918+ end: (rangeOf1(Data_Array_NonEmpty.last(v.value2))).end

919+ };

920+ };

921+ throw new Error("Failed pattern match at PureScript.CST.Range (line 553, column 13 - line 561, column 8): " + [ v.constructor.name ]);

922+ }

923+};

924+var rangeOfDataMembers = {

925+ rangeOf: function (v) {

926+ if (v instanceof PureScript_CST_Types.DataAll) {

927+ return v.value0.range;

928+ };

929+ if (v instanceof PureScript_CST_Types.DataEnumerated) {

930+ return rangeOf2(v.value0);

931+ };

932+ throw new Error("Failed pattern match at PureScript.CST.Range (line 322, column 13 - line 326, column 16): " + [ v.constructor.name ]);

933+ }

934+};

935+var rangeOf4 = /* #__PURE__ */ rangeOf(rangeOfDataMembers);

936+var rangeOfExport = function (dictRangeOf) {

937+ var rangeOf9 = rangeOf(dictRangeOf);

938+ return {

939+ rangeOf: function (v) {

940+ if (v instanceof PureScript_CST_Types.ExportValue) {

941+ return rangeOf1(v.value0);

942+ };

943+ if (v instanceof PureScript_CST_Types.ExportOp) {

944+ return rangeOf1(v.value0);

945+ };

946+ if (v instanceof PureScript_CST_Types.ExportType) {

947+ if (v.value1 instanceof Data_Maybe.Nothing) {

948+ return rangeOf1(v.value0);

949+ };

950+ if (v.value1 instanceof Data_Maybe.Just) {

951+ return {

952+ start: (rangeOf1(v.value0)).start,

953+ end: (rangeOf4(v.value1.value0)).end

954+ };

955+ };

956+ throw new Error("Failed pattern match at PureScript.CST.Range (line 282, column 7 - line 288, column 12): " + [ v.value1.constructor.name ]);

957+ };

958+ if (v instanceof PureScript_CST_Types.ExportTypeOp) {

959+ return {

960+ start: v.value0.range.start,

961+ end: (rangeOf1(v.value1)).end

962+ };

963+ };

964+ if (v instanceof PureScript_CST_Types.ExportClass) {

965+ return {

966+ start: v.value0.range.start,

967+ end: (rangeOf1(v.value1)).end

968+ };

969+ };

970+ if (v instanceof PureScript_CST_Types.ExportModule) {

971+ return {

972+ start: v.value0.range.start,

973+ end: (rangeOf1(v.value1)).end

974+ };

975+ };

976+ if (v instanceof PureScript_CST_Types.ExportError) {

977+ return rangeOf9(v.value0);

978+ };

979+ throw new Error("Failed pattern match at PureScript.CST.Range (line 276, column 13 - line 302, column 16): " + [ v.constructor.name ]);

980+ }

981+ };

982+};

983+var rangeOfFixityOp = {

984+ rangeOf: function (v) {

985+ if (v instanceof PureScript_CST_Types.FixityValue) {

986+ return {

987+ start: (rangeOf3(v.value0)).start,

988+ end: (rangeOf1(v.value2)).end

989+ };

990+ };

991+ if (v instanceof PureScript_CST_Types.FixityType) {

992+ return {

993+ start: v.value0.range.start,

994+ end: (rangeOf1(v.value3)).end

995+ };

996+ };

997+ throw new Error("Failed pattern match at PureScript.CST.Range (line 632, column 13 - line 640, column 8): " + [ v.constructor.name ]);

998+ }

999+};

1000+var rangeOf5 = /* #__PURE__ */ rangeOf(rangeOfFixityOp);

1001+var rangeOfImport = function (dictRangeOf) {

1002+ var rangeOf9 = rangeOf(dictRangeOf);

1003+ return {

1004+ rangeOf: function (v) {

1005+ if (v instanceof PureScript_CST_Types.ImportValue) {

1006+ return rangeOf1(v.value0);

1007+ };

1008+ if (v instanceof PureScript_CST_Types.ImportOp) {

1009+ return rangeOf1(v.value0);

1010+ };

1011+ if (v instanceof PureScript_CST_Types.ImportType) {

1012+ if (v.value1 instanceof Data_Maybe.Nothing) {

1013+ return rangeOf1(v.value0);

1014+ };

1015+ if (v.value1 instanceof Data_Maybe.Just) {

1016+ return {

1017+ start: (rangeOf1(v.value0)).start,

1018+ end: (rangeOf4(v.value1.value0)).end

1019+ };

1020+ };

1021+ throw new Error("Failed pattern match at PureScript.CST.Range (line 365, column 7 - line 371, column 12): " + [ v.value1.constructor.name ]);

1022+ };

1023+ if (v instanceof PureScript_CST_Types.ImportTypeOp) {

1024+ return {

1025+ start: v.value0.range.start,

1026+ end: (rangeOf1(v.value1)).end

1027+ };

1028+ };

1029+ if (v instanceof PureScript_CST_Types.ImportClass) {

1030+ return {

1031+ start: v.value0.range.start,

1032+ end: (rangeOf1(v.value1)).end

1033+ };

1034+ };

1035+ if (v instanceof PureScript_CST_Types.ImportError) {

1036+ return rangeOf9(v.value0);

1037+ };

1038+ throw new Error("Failed pattern match at PureScript.CST.Range (line 359, column 13 - line 381, column 16): " + [ v.constructor.name ]);

1039+ }

1040+ };

1041+};

1042+var rangeOfImportDecl = {

1043+ rangeOf: function (v) {

1044+ var v1 = (function () {

1045+ if (v.qualified instanceof Data_Maybe.Nothing) {

1046+ if (v.names instanceof Data_Maybe.Nothing) {

1047+ return rangeOf1(v.module);

1048+ };

1049+ if (v.names instanceof Data_Maybe.Just) {

1050+ return rangeOf2(v.names.value0.value1);

1051+ };

1052+ throw new Error("Failed pattern match at PureScript.CST.Range (line 340, column 11 - line 344, column 30): " + [ v.names.constructor.name ]);

1053+ };

1054+ if (v.qualified instanceof Data_Maybe.Just) {

1055+ return rangeOf1(v.qualified.value0.value1);

1056+ };

1057+ throw new Error("Failed pattern match at PureScript.CST.Range (line 338, column 17 - line 346, column 20): " + [ v.qualified.constructor.name ]);

1058+ })();

1059+ return {

1060+ start: v.keyword.range.start,

1061+ end: v1.end

1062+ };

1063+ }

1064+};

1065+var rangeOfLabeled = function (dictRangeOf) {

1066+ var rangeOf9 = rangeOf(dictRangeOf);

1067+ return function (dictRangeOf1) {

1068+ var rangeOf10 = rangeOf(dictRangeOf1);

1069+ return {

1070+ rangeOf: function (v) {

1071+ return {

1072+ start: (rangeOf9(v.label)).start,

1073+ end: (rangeOf10(v.value)).end

1074+ };

1075+ }

1076+ };

1077+ };

1078+};

1079+var rangeOfLabeled1 = /* #__PURE__ */ rangeOfLabeled(rangeOfName);

1080+var rangeOfOneOrDelimited = function (dictRangeOf) {

1081+ var rangeOf9 = rangeOf(dictRangeOf);

1082+ return {

1083+ rangeOf: function (v) {

1084+ if (v instanceof PureScript_CST_Types.One) {

1085+ return rangeOf9(v.value0);

1086+ };

1087+ if (v instanceof PureScript_CST_Types.Many) {

1088+ return rangeOf2(v.value0);

1089+ };

1090+ throw new Error("Failed pattern match at PureScript.CST.Range (line 143, column 13 - line 145, column 26): " + [ v.constructor.name ]);

1091+ }

1092+ };

1093+};

1094+var rangeOfPrefixed = function (dictRangeOf) {

1095+ var rangeOf9 = rangeOf(dictRangeOf);

1096+ return {

1097+ rangeOf: function (v) {

1098+ if (v.prefix instanceof Data_Maybe.Just) {

1099+ return {

1100+ start: v.prefix.value0.range.start,

1101+ end: (rangeOf9(v.value)).end

1102+ };

1103+ };

1104+ if (v.prefix instanceof Data_Maybe.Nothing) {

1105+ return rangeOf9(v.value);

1106+ };

1107+ throw new Error("Failed pattern match at PureScript.CST.Range (line 126, column 5 - line 132, column 22): " + [ v.prefix.constructor.name ]);

1108+ }

1109+ };

1110+};

1111+var rangeOfSeparated = function (dictRangeOf) {

1112+ var rangeOf9 = rangeOf(dictRangeOf);

1113+ return {

1114+ rangeOf: function (v) {

1115+ var v1 = Data_Array.last(v.tail);

1116+ if (v1 instanceof Data_Maybe.Just) {

1117+ return {

1118+ start: (rangeOf9(v.head)).start,

1119+ end: (rangeOf9(v1.value0.value1)).end

1120+ };

1121+ };

1122+ if (v1 instanceof Data_Maybe.Nothing) {

1123+ return rangeOf9(v.head);

1124+ };

1125+ throw new Error("Failed pattern match at PureScript.CST.Range (line 101, column 5 - line 107, column 21): " + [ v1.constructor.name ]);

1126+ }

1127+ };

1128+};

1129+var rangeOf6 = /* #__PURE__ */ rangeOf(/* #__PURE__ */ rangeOfSeparated(rangeOfName));

1130+var rangeOf7 = /* #__PURE__ */ rangeOf(/* #__PURE__ */ rangeOfSeparated(rangeOfClassFundep));

1131+var rangeOfType = function (dictRangeOf) {

1132+ var rangeOf9 = rangeOf(dictRangeOf);

1133+ return {

1134+ rangeOf: function (v) {

1135+ if (v instanceof PureScript_CST_Types.TypeVar) {

1136+ return rangeOf1(v.value0);

1137+ };

1138+ if (v instanceof PureScript_CST_Types.TypeConstructor) {

1139+ return rangeOf3(v.value0);

1140+ };

1141+ if (v instanceof PureScript_CST_Types.TypeWildcard) {

1142+ return v.value0.range;

1143+ };

1144+ if (v instanceof PureScript_CST_Types.TypeHole) {

1145+ return rangeOf1(v.value0);

1146+ };

1147+ if (v instanceof PureScript_CST_Types.TypeString) {

1148+ return v.value0.range;

1149+ };

1150+ if (v instanceof PureScript_CST_Types.TypeInt) {

1151+ if (v.value0 instanceof Data_Maybe.Nothing) {

1152+ return v.value1.range;

1153+ };

1154+ if (v.value0 instanceof Data_Maybe.Just) {

1155+ return {

1156+ start: v.value0.value0.range.start,

1157+ end: v.value1.range.end

1158+ };

1159+ };

1160+ throw new Error("Failed pattern match at PureScript.CST.Range (line 165, column 7 - line 171, column 12): " + [ v.value0.constructor.name ]);

1161+ };

1162+ if (v instanceof PureScript_CST_Types.TypeRow) {

1163+ return rangeOf2(v.value0);

1164+ };

1165+ if (v instanceof PureScript_CST_Types.TypeRecord) {

1166+ return rangeOf2(v.value0);

1167+ };

1168+ if (v instanceof PureScript_CST_Types.TypeForall) {

1169+ return {

1170+ start: v.value0.range.start,

1171+ end: (rangeOf(rangeOfType(dictRangeOf))(v.value3)).end

1172+ };

1173+ };

1174+ if (v instanceof PureScript_CST_Types.TypeKinded) {

1175+ return {

1176+ start: (rangeOf(rangeOfType(dictRangeOf))(v.value0)).start,

1177+ end: (rangeOf(rangeOfType(dictRangeOf))(v.value2)).end

1178+ };

1179+ };

1180+ if (v instanceof PureScript_CST_Types.TypeApp) {

1181+ return {

1182+ start: (rangeOf(rangeOfType(dictRangeOf))(v.value0)).start,

1183+ end: (rangeOf(rangeOfType(dictRangeOf))(Data_Array_NonEmpty.last(v.value1))).end

1184+ };

1185+ };

1186+ if (v instanceof PureScript_CST_Types.TypeOp) {

1187+ return {

1188+ start: (rangeOf(rangeOfType(dictRangeOf))(v.value0)).start,

1189+ end: (rangeOf(rangeOfType(dictRangeOf))(Data_Tuple.snd(Data_Array_NonEmpty.last(v.value1)))).end

1190+ };

1191+ };

1192+ if (v instanceof PureScript_CST_Types.TypeOpName) {

1193+ return rangeOf3(v.value0);

1194+ };

1195+ if (v instanceof PureScript_CST_Types.TypeArrow) {

1196+ return {

1197+ start: (rangeOf(rangeOfType(dictRangeOf))(v.value0)).start,

1198+ end: (rangeOf(rangeOfType(dictRangeOf))(v.value2)).end

1199+ };

1200+ };

1201+ if (v instanceof PureScript_CST_Types.TypeArrowName) {

1202+ return v.value0.range;

1203+ };

1204+ if (v instanceof PureScript_CST_Types.TypeConstrained) {

1205+ return {

1206+ start: (rangeOf(rangeOfType(dictRangeOf))(v.value0)).start,

1207+ end: (rangeOf(rangeOfType(dictRangeOf))(v.value2)).end

1208+ };

1209+ };

1210+ if (v instanceof PureScript_CST_Types.TypeParens) {

1211+ return rangeOf2(v.value0);

1212+ };

1213+ if (v instanceof PureScript_CST_Types["TypeError"]) {

1214+ return rangeOf9(v.value0);

1215+ };

1216+ throw new Error("Failed pattern match at PureScript.CST.Range (line 153, column 13 - line 207, column 16): " + [ v.constructor.name ]);

1217+ }

1218+ };

1219+};

1220+var rangeOfAppSpine = function (dictRangeOf) {

1221+ var rangeOf9 = rangeOf(rangeOfType(dictRangeOf));

1222+ return function (dictRangeOf1) {

1223+ var rangeOf10 = rangeOf(dictRangeOf1);

1224+ return {

1225+ rangeOf: function (v) {

1226+ if (v instanceof PureScript_CST_Types.AppType) {

1227+ return {

1228+ start: v.value0.range.start,

1229+ end: (rangeOf9(v.value1)).end

1230+ };

1231+ };

1232+ if (v instanceof PureScript_CST_Types.AppTerm) {

1233+ return rangeOf10(v.value0);

1234+ };

1235+ throw new Error("Failed pattern match at PureScript.CST.Range (line 847, column 13 - line 853, column 16): " + [ v.constructor.name ]);

1236+ }

1237+ };

1238+ };

1239+};

1240+var rangeOfBinder = function (dictRangeOf) {

1241+ var rangeOf9 = rangeOf(rangeOfType(dictRangeOf));

1242+ var rangeOf10 = rangeOf(dictRangeOf);

1243+ return {

1244+ rangeOf: function (v) {

1245+ if (v instanceof PureScript_CST_Types.BinderWildcard) {

1246+ return v.value0.range;

1247+ };

1248+ if (v instanceof PureScript_CST_Types.BinderVar) {

1249+ return rangeOf1(v.value0);

1250+ };

1251+ if (v instanceof PureScript_CST_Types.BinderNamed) {

1252+ return {

1253+ start: (rangeOf1(v.value0)).start,

1254+ end: (rangeOf(rangeOfBinder(dictRangeOf))(v.value2)).end

1255+ };

1256+ };

1257+ if (v instanceof PureScript_CST_Types.BinderConstructor) {

1258+ var v1 = Data_Array.last(v.value1);

1259+ if (v1 instanceof Data_Maybe.Nothing) {

1260+ return rangeOf3(v.value0);

1261+ };

1262+ if (v1 instanceof Data_Maybe.Just) {

1263+ return {

1264+ start: (rangeOf3(v.value0)).start,

1265+ end: (rangeOf(rangeOfBinder(dictRangeOf))(v1.value0)).end

1266+ };

1267+ };

1268+ throw new Error("Failed pattern match at PureScript.CST.Range (line 932, column 7 - line 938, column 12): " + [ v1.constructor.name ]);

1269+ };

1270+ if (v instanceof PureScript_CST_Types.BinderBoolean) {

1271+ return v.value0.range;

1272+ };

1273+ if (v instanceof PureScript_CST_Types.BinderChar) {

1274+ return v.value0.range;

1275+ };

1276+ if (v instanceof PureScript_CST_Types.BinderString) {

1277+ return v.value0.range;

1278+ };

1279+ if (v instanceof PureScript_CST_Types.BinderInt) {

1280+ if (v.value0 instanceof Data_Maybe.Nothing) {

1281+ return v.value1.range;

1282+ };

1283+ if (v.value0 instanceof Data_Maybe.Just) {

1284+ return {

1285+ start: v.value0.value0.range.start,

1286+ end: v.value1.range.end

1287+ };

1288+ };

1289+ throw new Error("Failed pattern match at PureScript.CST.Range (line 946, column 7 - line 952, column 12): " + [ v.value0.constructor.name ]);

1290+ };

1291+ if (v instanceof PureScript_CST_Types.BinderNumber) {

1292+ if (v.value0 instanceof Data_Maybe.Nothing) {

1293+ return v.value1.range;

1294+ };

1295+ if (v.value0 instanceof Data_Maybe.Just) {

1296+ return {

1297+ start: v.value0.value0.range.start,

1298+ end: v.value1.range.end

1299+ };

1300+ };

1301+ throw new Error("Failed pattern match at PureScript.CST.Range (line 954, column 7 - line 960, column 12): " + [ v.value0.constructor.name ]);

1302+ };

1303+ if (v instanceof PureScript_CST_Types.BinderArray) {

1304+ return rangeOf2(v.value0);

1305+ };

1306+ if (v instanceof PureScript_CST_Types.BinderRecord) {

1307+ return rangeOf2(v.value0);

1308+ };

1309+ if (v instanceof PureScript_CST_Types.BinderParens) {

1310+ return rangeOf2(v.value0);

1311+ };

1312+ if (v instanceof PureScript_CST_Types.BinderTyped) {

1313+ return {

1314+ start: (rangeOf(rangeOfBinder(dictRangeOf))(v.value0)).start,

1315+ end: (rangeOf9(v.value2)).end

1316+ };

1317+ };

1318+ if (v instanceof PureScript_CST_Types.BinderOp) {

1319+ return {

1320+ start: (rangeOf(rangeOfBinder(dictRangeOf))(v.value0)).start,

1321+ end: (rangeOf(rangeOfBinder(dictRangeOf))(Data_Tuple.snd(Data_Array_NonEmpty.last(v.value1)))).end

1322+ };

1323+ };

1324+ if (v instanceof PureScript_CST_Types.BinderError) {

1325+ return rangeOf10(v.value0);

1326+ };

1327+ throw new Error("Failed pattern match at PureScript.CST.Range (line 922, column 13 - line 976, column 16): " + [ v.constructor.name ]);

1328+ }

1329+ };

1330+};

1331+var rangeOfDataCtor = function (dictRangeOf) {

1332+ var rangeOf9 = rangeOf(rangeOfType(dictRangeOf));

1333+ return {

1334+ rangeOf: function (v) {

1335+ var v1 = (function () {

1336+ var v2 = Data_Array.last(v.fields);

1337+ if (v2 instanceof Data_Maybe.Nothing) {

1338+ return rangeOf1(v.name);

1339+ };

1340+ if (v2 instanceof Data_Maybe.Just) {

1341+ return rangeOf9(v2.value0);

1342+ };

1343+ throw new Error("Failed pattern match at PureScript.CST.Range (line 401, column 17 - line 405, column 21): " + [ v2.constructor.name ]);

1344+ })();

1345+ return {

1346+ start: (rangeOf1(v.name)).start,

1347+ end: v1.end

1348+ };

1349+ }

1350+ };

1351+};

1352+var rangeOfForeign = function (dictRangeOf) {

1353+ var rangeOf9 = rangeOf(rangeOfLabeled1(rangeOfType(dictRangeOf)));

1354+ return {

1355+ rangeOf: function (v) {

1356+ if (v instanceof PureScript_CST_Types.ForeignValue) {

1357+ return rangeOf9(v.value0);

1358+ };

1359+ if (v instanceof PureScript_CST_Types.ForeignData) {

1360+ return {

1361+ start: v.value0.range.start,

1362+ end: (rangeOf9(v.value1)).end

1363+ };

1364+ };

1365+ if (v instanceof PureScript_CST_Types.ForeignKind) {

1366+ return {

1367+ start: v.value0.range.start,

1368+ end: (rangeOf1(v.value1)).end

1369+ };

1370+ };

1371+ throw new Error("Failed pattern match at PureScript.CST.Range (line 650, column 13 - line 660, column 8): " + [ v.constructor.name ]);

1372+ }

1373+ };

1374+};

1375+var rangeOfTypeVarBinding = function (dictRangeOf) {

1376+ var rangeOf9 = rangeOf(dictRangeOf);

1377+ return {

1378+ rangeOf: function (v) {

1379+ if (v instanceof PureScript_CST_Types.TypeVarKinded) {

1380+ return rangeOf2(v.value0);

1381+ };

1382+ if (v instanceof PureScript_CST_Types.TypeVarName) {

1383+ return rangeOf9(v.value0);

1384+ };

1385+ throw new Error("Failed pattern match at PureScript.CST.Range (line 262, column 13 - line 266, column 16): " + [ v.constructor.name ]);

1386+ }

1387+ };

1388+};

1389+var rangeOf8 = /* #__PURE__ */ rangeOf(/* #__PURE__ */ rangeOfTypeVarBinding(rangeOfName));

1390+var rangeOfWhere = function (dictRangeOf) {

1391+ return {

1392+ rangeOf: function (v) {

1393+ if (v.bindings instanceof Data_Maybe.Nothing) {

1394+ return rangeOf(rangeOfExpr(dictRangeOf))(v.expr);

1395+ };

1396+ if (v.bindings instanceof Data_Maybe.Just) {

1397+ return {

1398+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.expr)).start,

1399+ end: (rangeOf(rangeOfLetBinding(dictRangeOf))(Data_Array_NonEmpty.last(v.bindings.value0.value1))).end

1400+ };

1401+ };

1402+ throw new Error("Failed pattern match at PureScript.CST.Range (line 1019, column 40 - line 1025, column 8): " + [ v.bindings.constructor.name ]);

1403+ }

1404+ };

1405+};

1406+var rangeOfLetBinding = function (dictRangeOf) {

1407+ var rangeOf9 = rangeOf(rangeOfLabeled1(rangeOfType(dictRangeOf)));

1408+ var rangeOf10 = rangeOf(rangeOfBinder(dictRangeOf));

1409+ var rangeOf11 = rangeOf(dictRangeOf);

1410+ return {

1411+ rangeOf: function (v) {

1412+ if (v instanceof PureScript_CST_Types.LetBindingSignature) {

1413+ return rangeOf9(v.value0);

1414+ };

1415+ if (v instanceof PureScript_CST_Types.LetBindingName) {

1416+ return {

1417+ start: (rangeOf1(v.value0.name)).start,

1418+ end: (rangeOf(rangeOfGuarded(dictRangeOf))(v.value0.guarded)).end

1419+ };

1420+ };

1421+ if (v instanceof PureScript_CST_Types.LetBindingPattern) {

1422+ return {

1423+ start: (rangeOf10(v.value0)).start,

1424+ end: (rangeOf(rangeOfWhere(dictRangeOf))(v.value2)).end

1425+ };

1426+ };

1427+ if (v instanceof PureScript_CST_Types.LetBindingError) {

1428+ return rangeOf11(v.value0);

1429+ };

1430+ throw new Error("Failed pattern match at PureScript.CST.Range (line 896, column 13 - line 908, column 16): " + [ v.constructor.name ]);

1431+ }

1432+ };

1433+};

1434+var rangeOfGuardedExpr = function (dictRangeOf) {

1435+ return {

1436+ rangeOf: function (v) {

1437+ return {

1438+ start: v.bar.range.start,

1439+ end: (rangeOf(rangeOfWhere(dictRangeOf))(v.where)).end

1440+ };

1441+ }

1442+ };

1443+};

1444+var rangeOfGuarded = function (dictRangeOf) {

1445+ return {

1446+ rangeOf: function (v) {

1447+ if (v instanceof PureScript_CST_Types.Unconditional) {

1448+ return {

1449+ start: v.value0.range.start,

1450+ end: (rangeOf(rangeOfWhere(dictRangeOf))(v.value1)).end

1451+ };

1452+ };

1453+ if (v instanceof PureScript_CST_Types.Guarded) {

1454+ return {

1455+ start: (rangeOf(rangeOfGuardedExpr(dictRangeOf))(Data_Array_NonEmpty.head(v.value0))).start,

1456+ end: (rangeOf(rangeOfGuardedExpr(dictRangeOf))(Data_Array_NonEmpty.last(v.value0))).end

1457+ };

1458+ };

1459+ throw new Error("Failed pattern match at PureScript.CST.Range (line 596, column 13 - line 604, column 8): " + [ v.constructor.name ]);

1460+ }

1461+ };

1462+};

1463+var rangeOfExpr = function (dictRangeOf) {

1464+ var rangeOf9 = rangeOf(rangeOfType(dictRangeOf));

1465+ var rangeOfAppSpine1 = rangeOfAppSpine(dictRangeOf);

1466+ var rangeOf10 = rangeOf(dictRangeOf);

1467+ return {

1468+ rangeOf: function (v) {

1469+ if (v instanceof PureScript_CST_Types.ExprHole) {

1470+ return rangeOf1(v.value0);

1471+ };

1472+ if (v instanceof PureScript_CST_Types.ExprSection) {

1473+ return v.value0.range;

1474+ };

1475+ if (v instanceof PureScript_CST_Types.ExprIdent) {

1476+ return rangeOf3(v.value0);

1477+ };

1478+ if (v instanceof PureScript_CST_Types.ExprConstructor) {

1479+ return rangeOf3(v.value0);

1480+ };

1481+ if (v instanceof PureScript_CST_Types.ExprBoolean) {

1482+ return v.value0.range;

1483+ };

1484+ if (v instanceof PureScript_CST_Types.ExprChar) {

1485+ return v.value0.range;

1486+ };

1487+ if (v instanceof PureScript_CST_Types.ExprString) {

1488+ return v.value0.range;

1489+ };

1490+ if (v instanceof PureScript_CST_Types.ExprInt) {

1491+ return v.value0.range;

1492+ };

1493+ if (v instanceof PureScript_CST_Types.ExprNumber) {

1494+ return v.value0.range;

1495+ };

1496+ if (v instanceof PureScript_CST_Types.ExprArray) {

1497+ return rangeOf2(v.value0);

1498+ };

1499+ if (v instanceof PureScript_CST_Types.ExprRecord) {

1500+ return rangeOf2(v.value0);

1501+ };

1502+ if (v instanceof PureScript_CST_Types.ExprParens) {

1503+ return rangeOf2(v.value0);

1504+ };

1505+ if (v instanceof PureScript_CST_Types.ExprTyped) {

1506+ return {

1507+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0)).start,

1508+ end: (rangeOf9(v.value2)).end

1509+ };

1510+ };

1511+ if (v instanceof PureScript_CST_Types.ExprInfix) {

1512+ return {

1513+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0)).start,

1514+ end: (rangeOf(rangeOfExpr(dictRangeOf))(Data_Tuple.snd(Data_Array_NonEmpty.last(v.value1)))).end

1515+ };

1516+ };

1517+ if (v instanceof PureScript_CST_Types.ExprOp) {

1518+ return {

1519+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0)).start,

1520+ end: (rangeOf(rangeOfExpr(dictRangeOf))(Data_Tuple.snd(Data_Array_NonEmpty.last(v.value1)))).end

1521+ };

1522+ };

1523+ if (v instanceof PureScript_CST_Types.ExprOpName) {

1524+ return rangeOf3(v.value0);

1525+ };

1526+ if (v instanceof PureScript_CST_Types.ExprNegate) {

1527+ return {

1528+ start: v.value0.range.start,

1529+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v.value1)).end

1530+ };

1531+ };

1532+ if (v instanceof PureScript_CST_Types.ExprRecordAccessor) {

1533+ return {

1534+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0.expr)).start,

1535+ end: (rangeOf6(v.value0.path)).end

1536+ };

1537+ };

1538+ if (v instanceof PureScript_CST_Types.ExprRecordUpdate) {

1539+ return {

1540+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0)).start,

1541+ end: (rangeOf2(v.value1)).end

1542+ };

1543+ };

1544+ if (v instanceof PureScript_CST_Types.ExprApp) {

1545+ return {

1546+ start: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0)).start,

1547+ end: (rangeOf(rangeOfAppSpine1(rangeOfExpr(dictRangeOf)))(Data_Array_NonEmpty.last(v.value1))).end

1548+ };

1549+ };

1550+ if (v instanceof PureScript_CST_Types.ExprLambda) {

1551+ return {

1552+ start: v.value0.symbol.range.start,

1553+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0.body)).end

1554+ };

1555+ };

1556+ if (v instanceof PureScript_CST_Types.ExprIf) {

1557+ return {

1558+ start: v.value0.keyword.range.start,

1559+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v["value0"]["false"])).end

1560+ };

1561+ };

1562+ if (v instanceof PureScript_CST_Types.ExprCase) {

1563+ return {

1564+ start: v.value0.keyword.range.start,

1565+ end: (rangeOf(rangeOfGuarded(dictRangeOf))(Data_Tuple.snd(Data_Array_NonEmpty.last(v.value0.branches)))).end

1566+ };

1567+ };

1568+ if (v instanceof PureScript_CST_Types.ExprLet) {

1569+ return {

1570+ start: v.value0.keyword.range.start,

1571+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0.body)).end

1572+ };

1573+ };

1574+ if (v instanceof PureScript_CST_Types.ExprDo) {

1575+ return {

1576+ start: v.value0.keyword.range.start,

1577+ end: (rangeOf(rangeOfDoStatement(dictRangeOf))(Data_Array_NonEmpty.last(v.value0.statements))).end

1578+ };

1579+ };

1580+ if (v instanceof PureScript_CST_Types.ExprAdo) {

1581+ return {

1582+ start: v.value0.keyword.range.start,

1583+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v.value0.result)).end

1584+ };

1585+ };

1586+ if (v instanceof PureScript_CST_Types.ExprError) {

1587+ return rangeOf10(v.value0);

1588+ };

1589+ throw new Error("Failed pattern match at PureScript.CST.Range (line 690, column 13 - line 770, column 16): " + [ v.constructor.name ]);

1590+ }

1591+ };

1592+};

1593+var rangeOfDoStatement = function (dictRangeOf) {

1594+ var rangeOf9 = rangeOf(rangeOfBinder(dictRangeOf));

1595+ var rangeOf10 = rangeOf(dictRangeOf);

1596+ return {

1597+ rangeOf: function (v) {

1598+ if (v instanceof PureScript_CST_Types.DoLet) {

1599+ return {

1600+ start: v.value0.range.start,

1601+ end: (rangeOf(rangeOfLetBinding(dictRangeOf))(Data_Array_NonEmpty.last(v.value1))).end

1602+ };

1603+ };

1604+ if (v instanceof PureScript_CST_Types.DoDiscard) {

1605+ return rangeOf(rangeOfExpr(dictRangeOf))(v.value0);

1606+ };

1607+ if (v instanceof PureScript_CST_Types.DoBind) {

1608+ return {

1609+ start: (rangeOf9(v.value0)).start,

1610+ end: (rangeOf(rangeOfExpr(dictRangeOf))(v.value2)).end

1611+ };

1612+ };

1613+ if (v instanceof PureScript_CST_Types.DoError) {

1614+ return rangeOf10(v.value0);

1615+ };

1616+ throw new Error("Failed pattern match at PureScript.CST.Range (line 870, column 13 - line 882, column 16): " + [ v.constructor.name ]);

1617+ }

1618+ };

1619+};

1620+var rangeOfInstanceBinding = function (dictRangeOf) {

1621+ var rangeOf9 = rangeOf(rangeOfLabeled1(rangeOfType(dictRangeOf)));

1622+ var rangeOf10 = rangeOf(rangeOfGuarded(dictRangeOf));

1623+ return {

1624+ rangeOf: function (v) {

1625+ if (v instanceof PureScript_CST_Types.InstanceBindingSignature) {

1626+ return rangeOf9(v.value0);

1627+ };

1628+ if (v instanceof PureScript_CST_Types.InstanceBindingName) {

1629+ return {

1630+ start: (rangeOf1(v.value0.name)).start,

1631+ end: (rangeOf10(v.value0.guarded)).end

1632+ };

1633+ };

1634+ throw new Error("Failed pattern match at PureScript.CST.Range (line 672, column 13 - line 678, column 8): " + [ v.constructor.name ]);

1635+ }

1636+ };

1637+};

1638+var rangeOfInstance = function (dictRangeOf) {

1639+ var rangeOf9 = rangeOf(rangeOfType(dictRangeOf));

1640+ var rangeOf10 = rangeOf(rangeOfInstanceBinding(dictRangeOf));

1641+ return {

1642+ rangeOf: function (v) {

1643+ var v1 = (function () {

1644+ if (v.body instanceof Data_Maybe.Nothing) {

1645+ var v2 = Data_Array.last(v.head.types);

1646+ if (v2 instanceof Data_Maybe.Nothing) {

1647+ return rangeOf3(v.head.className);

1648+ };

1649+ if (v2 instanceof Data_Maybe.Just) {

1650+ return rangeOf9(v2.value0);

1651+ };

1652+ throw new Error("Failed pattern match at PureScript.CST.Range (line 575, column 11 - line 579, column 25): " + [ v2.constructor.name ]);

1653+ };

1654+ if (v.body instanceof Data_Maybe.Just) {

1655+ return rangeOf10(Data_Array_NonEmpty.last(v.body.value0.value1));

1656+ };

1657+ throw new Error("Failed pattern match at PureScript.CST.Range (line 573, column 17 - line 581, column 42): " + [ v.body.constructor.name ]);

1658+ })();

1659+ return {

1660+ start: v.head.keyword.range.start,

1661+ end: v1.end

1662+ };

1663+ }

1664+ };

1665+};

1666+var rangeOfDecl = function (dictRangeOf) {

1667+ var rangeOf9 = rangeOf(rangeOfDataCtor(dictRangeOf));

1668+ var rangeOfType1 = rangeOfType(dictRangeOf);

1669+ var rangeOf10 = rangeOf(rangeOfType1);

1670+ var rangeOf11 = rangeOf(rangeOfLabeled1(rangeOfType1));

1671+ var rangeOf12 = rangeOf(rangeOfSeparated(rangeOfInstance(dictRangeOf)));

1672+ var rangeOf13 = rangeOf(rangeOfGuarded(dictRangeOf));

1673+ var rangeOf14 = rangeOf(rangeOfForeign(dictRangeOf));

1674+ var rangeOf15 = rangeOf(dictRangeOf);

1675+ return {

1676+ rangeOf: function (v) {

1677+ if (v instanceof PureScript_CST_Types.DeclData) {

1678+ var v1 = (function () {

1679+ if (v.value1 instanceof Data_Maybe.Nothing) {

1680+ var v2 = Data_Array.last(v.value0.vars);

1681+ if (v2 instanceof Data_Maybe.Nothing) {

1682+ return rangeOf1(v.value0.name);

1683+ };

1684+ if (v2 instanceof Data_Maybe.Just) {

1685+ return rangeOf8(v2.value0);

1686+ };

1687+ throw new Error("Failed pattern match at PureScript.CST.Range (line 420, column 13 - line 424, column 28): " + [ v2.constructor.name ]);

1688+ };

1689+ if (v.value1 instanceof Data_Maybe.Just) {

1690+ return rangeOf9(Data_Maybe.maybe(v.value1.value0.value1.head)(Data_Tuple.snd)(Data_Array.last(v.value1.value0.value1.tail)));

1691+ };

1692+ throw new Error("Failed pattern match at PureScript.CST.Range (line 418, column 19 - line 426, column 55): " + [ v.value1.constructor.name ]);

1693+ })();

1694+ return {

1695+ start: v.value0.keyword.range.start,

1696+ end: v1.end

1697+ };

1698+ };

1699+ if (v instanceof PureScript_CST_Types.DeclType) {

1700+ return {

1701+ start: v.value0.keyword.range.start,

1702+ end: (rangeOf10(v.value2)).end

1703+ };

1704+ };

1705+ if (v instanceof PureScript_CST_Types.DeclNewtype) {

1706+ return {

1707+ start: v.value0.keyword.range.start,

1708+ end: (rangeOf10(v.value3)).end

1709+ };

1710+ };

1711+ if (v instanceof PureScript_CST_Types.DeclClass) {

1712+ var v1 = (function () {

1713+ if (v.value1 instanceof Data_Maybe.Nothing) {

1714+ if (v.value0.fundeps instanceof Data_Maybe.Nothing) {

1715+ var v2 = Data_Array.last(v.value0.vars);

1716+ if (v2 instanceof Data_Maybe.Nothing) {

1717+ return rangeOf1(v.value0.name);

1718+ };

1719+ if (v2 instanceof Data_Maybe.Just) {

1720+ return rangeOf8(v2.value0);

1721+ };

1722+ throw new Error("Failed pattern match at PureScript.CST.Range (line 444, column 17 - line 448, column 32): " + [ v2.constructor.name ]);

1723+ };

1724+ if (v.value0.fundeps instanceof Data_Maybe.Just) {

1725+ return rangeOf7(v.value0.fundeps.value0.value1);

1726+ };

1727+ throw new Error("Failed pattern match at PureScript.CST.Range (line 442, column 13 - line 450, column 32): " + [ v.value0.fundeps.constructor.name ]);

1728+ };

1729+ if (v.value1 instanceof Data_Maybe.Just) {

1730+ return rangeOf11(Data_Array_NonEmpty.last(v.value1.value0.value1));

1731+ };

1732+ throw new Error("Failed pattern match at PureScript.CST.Range (line 440, column 19 - line 452, column 44): " + [ v.value1.constructor.name ]);

1733+ })();

1734+ return {

1735+ start: v.value0.keyword.range.start,

1736+ end: v1.end

1737+ };

1738+ };

1739+ if (v instanceof PureScript_CST_Types.DeclInstanceChain) {

1740+ return rangeOf12(v.value0);

1741+ };

1742+ if (v instanceof PureScript_CST_Types.DeclDerive) {

1743+ var v1 = (function () {

1744+ var v2 = Data_Array.last(v.value2.types);

1745+ if (v2 instanceof Data_Maybe.Nothing) {

1746+ return rangeOf3(v.value2.className);

1747+ };

1748+ if (v2 instanceof Data_Maybe.Just) {

1749+ return rangeOf10(v2.value0);

1750+ };

1751+ throw new Error("Failed pattern match at PureScript.CST.Range (line 460, column 19 - line 464, column 23): " + [ v2.constructor.name ]);

1752+ })();

1753+ return {

1754+ start: v.value0.range.start,

1755+ end: v1.end

1756+ };

1757+ };

1758+ if (v instanceof PureScript_CST_Types.DeclKindSignature) {

1759+ return {

1760+ start: v.value0.range.start,

1761+ end: (rangeOf11(v.value1)).end

1762+ };

1763+ };

1764+ if (v instanceof PureScript_CST_Types.DeclSignature) {

1765+ return rangeOf11(v.value0);

1766+ };

1767+ if (v instanceof PureScript_CST_Types.DeclValue) {

1768+ return {

1769+ start: (rangeOf1(v.value0.name)).start,

1770+ end: (rangeOf13(v.value0.guarded)).end

1771+ };

1772+ };

1773+ if (v instanceof PureScript_CST_Types.DeclFixity) {

1774+ return {

1775+ start: v.value0.keyword.value0.range.start,

1776+ end: (rangeOf5(v.value0.operator)).end

1777+ };

1778+ };

1779+ if (v instanceof PureScript_CST_Types.DeclForeign) {

1780+ return {

1781+ start: v.value0.range.start,

1782+ end: (rangeOf14(v.value2)).end

1783+ };

1784+ };

1785+ if (v instanceof PureScript_CST_Types.DeclRole) {

1786+ return {

1787+ start: v.value0.range.start,

1788+ end: (Data_Tuple.fst(Data_Array_NonEmpty.last(v.value3))).range.end

1789+ };

1790+ };

1791+ if (v instanceof PureScript_CST_Types.DeclError) {

1792+ return rangeOf15(v.value0);

1793+ };

1794+ throw new Error("Failed pattern match at PureScript.CST.Range (line 415, column 13 - line 491, column 16): " + [ v.constructor.name ]);

1795+ }

1796+ };

1797+};

1798+export {

1799+ rangeOf,

1800+ tokensOf,

1801+ tokensOfTuple,

1802+ tokensOfMaybe,

1803+ tokensOfArray,

1804+ tokensOfNonEmptyArray,

1805+ rangeOfVoid,

1806+ tokensOfVoid,

1807+ rangeOfRecoveredError,

1808+ tokensOfRecoveredError,

1809+ rangeOfModule,

1810+ tokensOfModule,

1811+ rangeOfName,

1812+ tokensOfName,

1813+ rangeOfQualifiedName,

1814+ tokensOfQualifiedName,

1815+ rangeOfWrapped,

1816+ tokensOfWrapped,

1817+ rangeOfSeparated,

1818+ tokensOfSeparated,

1819+ rangeOfLabeled,

1820+ tokensOfLabeled,

1821+ rangeOfPrefixed,

1822+ tokensOfPrefixed,

1823+ rangeOfOneOrDelimited,

1824+ tokensOfOneOrDelimited,

1825+ rangeOfType,

1826+ tokensOfType,

1827+ tokensOfRow,

1828+ rangeOfTypeVarBinding,

1829+ tokensOfTypeVarBinding,

1830+ rangeOfExport,

1831+ tokensOfExport,

1832+ rangeOfDataMembers,

1833+ tokensOfDataMembers,

1834+ rangeOfImportDecl,

1835+ tokensOfImportDecl,

1836+ rangeOfImport,

1837+ tokensOfImport,

1838+ rangeOfDataCtor,

1839+ tokensOfDataCtor,

1840+ rangeOfDecl,

1841+ tokensOfDecl,

1842+ rangeOfClassFundep,

1843+ tokensOfClassFundep,

1844+ rangeOfInstance,

1845+ tokensOfInstance,

1846+ rangeOfGuarded,

1847+ tokensOfGuarded,

1848+ rangeOfGuardedExpr,

1849+ tokensOfGuardedExpr,

1850+ tokensOfPatternGuard,

1851+ rangeOfFixityOp,

1852+ tokensOfFixityOp,

1853+ rangeOfForeign,

1854+ tokensOfForeign,

1855+ rangeOfInstanceBinding,

1856+ tokensOfInstanceBinding,

1857+ rangeOfExpr,

1858+ tokensOfExpr,

1859+ rangeOfAppSpine,

1860+ tokensOfAppSpine,

1861+ tokensOfRecordUpdate,

1862+ rangeOfDoStatement,

1863+ tokensOfDoStatement,

1864+ rangeOfLetBinding,

1865+ tokensOfLetBinding,

1866+ rangeOfBinder,

1867+ tokensOfBinder,

1868+ tokensOfRecordLabeled,

1869+ rangeOfWhere,

1870+ tokensOfWhere

1871+};

output-compile-fail/PureScript.CST.TokenStream/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.TokenStream/index.jsnew file+131

@@ -0,0 +1,131 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Boolean from "../Data.Boolean/index.js";

3+import * as Data_Foldable from "../Data.Foldable/index.js";

4+import * as Data_Function from "../Data.Function/index.js";

5+import * as Data_Lazy from "../Data.Lazy/index.js";

6+import * as Data_List_Types from "../Data.List.Types/index.js";

7+import * as Data_Newtype from "../Data.Newtype/index.js";

8+import * as Data_Tuple from "../Data.Tuple/index.js";

9+import * as PureScript_CST_Layout from "../PureScript.CST.Layout/index.js";

10+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

11+var TokenEOF = /* #__PURE__ */ (function () {

12+ function TokenEOF(value0, value1) {

13+ this.value0 = value0;

14+ this.value1 = value1;

15+ };

16+ TokenEOF.create = function (value0) {

17+ return function (value1) {

18+ return new TokenEOF(value0, value1);

19+ };

20+ };

21+ return TokenEOF;

22+})();

23+var TokenError = /* #__PURE__ */ (function () {

24+ function TokenError(value0, value1, value2, value3) {

25+ this.value0 = value0;

26+ this.value1 = value1;

27+ this.value2 = value2;

28+ this.value3 = value3;

29+ };

30+ TokenError.create = function (value0) {

31+ return function (value1) {

32+ return function (value2) {

33+ return function (value3) {

34+ return new TokenError(value0, value1, value2, value3);

35+ };

36+ };

37+ };

38+ };

39+ return TokenError;

40+})();

41+var TokenCons = /* #__PURE__ */ (function () {

42+ function TokenCons(value0, value1, value2, value3) {

43+ this.value0 = value0;

44+ this.value1 = value1;

45+ this.value2 = value2;

46+ this.value3 = value3;

47+ };

48+ TokenCons.create = function (value0) {

49+ return function (value1) {

50+ return function (value2) {

51+ return function (value3) {

52+ return new TokenCons(value0, value1, value2, value3);

53+ };

54+ };

55+ };

56+ };

57+ return TokenCons;

58+})();

59+var TokenStream = function (x) {

60+ return x;

61+};

62+var newtypeTokenStream = {

63+ Coercible0: function () {

64+ return undefined;

65+ }

66+};

67+var step = /* #__PURE__ */ (function () {

68+ var $32 = Data_Newtype.unwrap();

69+ return function ($33) {

70+ return Data_Lazy.force($32($33));

71+ };

72+})();

73+var unwindLayout = function (pos) {

74+ return function (eof) {

75+ var go = function (stk) {

76+ return Data_Lazy.defer(function (v) {

77+ if (stk instanceof Data_List_Types.Nil) {

78+ return step(eof);

79+ };

80+ if (stk instanceof Data_List_Types.Cons) {

81+ if (stk.value0.value1 instanceof PureScript_CST_Layout.LytRoot) {

82+ return step(eof);

83+ };

84+ if (PureScript_CST_Layout.isIndented(stk.value0.value1)) {

85+ return new TokenCons(PureScript_CST_Layout.lytToken(pos)(new PureScript_CST_Types.TokLayoutEnd(stk.value0.value0.column)), pos, go(stk.value1), stk.value1);

86+ };

87+ if (Data_Boolean.otherwise) {

88+ return step(go(stk.value1));

89+ };

90+ throw new Error("Failed pattern match at PureScript.CST.TokenStream (line 59, column 7 - line 66, column 27): " + [ stk.value0.value1.constructor.name ]);

91+ };

92+ throw new Error("Failed pattern match at PureScript.CST.TokenStream (line 56, column 43 - line 66, column 27): " + [ stk.constructor.name ]);

93+ });

94+ };

95+ return go;

96+ };

97+};

98+var layoutStack = function (stream) {

99+ var v = step(stream);

100+ if (v instanceof TokenEOF) {

101+ return Data_List_Types.Nil.value;

102+ };

103+ if (v instanceof TokenError) {

104+ return v.value3;

105+ };

106+ if (v instanceof TokenCons) {

107+ return v.value3;

108+ };

109+ throw new Error("Failed pattern match at PureScript.CST.TokenStream (line 48, column 22 - line 51, column 29): " + [ v.constructor.name ]);

110+};

111+var consTokens = function (dictFoldable) {

112+ var go = function (v) {

113+ return function (v1) {

114+ return new Data_Tuple.Tuple(v.value0.range.start, Data_Lazy.defer(function (v2) {

115+ return new TokenCons(v.value0, v1.value0, v1.value1, v.value1);

116+ }));

117+ };

118+ };

119+ return Data_Function.flip(Data_Foldable.foldr(dictFoldable)(go));

120+};

121+export {

122+ TokenStream,

123+ TokenEOF,

124+ TokenError,

125+ TokenCons,

126+ step,

127+ consTokens,

128+ layoutStack,

129+ unwindLayout,

130+ newtypeTokenStream

131+};

output-compile-fail/PureScript.CST.Traversal/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Traversal/index.jsnew file+1449

@@ -0,0 +1,1449 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Applicative from "../Control.Applicative/index.js";

3+import * as Control_Apply from "../Control.Apply/index.js";

4+import * as Control_Bind from "../Control.Bind/index.js";

5+import * as Control_Category from "../Control.Category/index.js";

6+import * as Control_Monad_Free from "../Control.Monad.Free/index.js";

7+import * as Control_Monad_Reader_Trans from "../Control.Monad.Reader.Trans/index.js";

8+import * as Data_Array_NonEmpty_Internal from "../Data.Array.NonEmpty.Internal/index.js";

9+import * as Data_Bitraversable from "../Data.Bitraversable/index.js";

10+import * as Data_Const from "../Data.Const/index.js";

11+import * as Data_Function from "../Data.Function/index.js";

12+import * as Data_Functor from "../Data.Functor/index.js";

13+import * as Data_Functor_Compose from "../Data.Functor.Compose/index.js";

14+import * as Data_Identity from "../Data.Identity/index.js";

15+import * as Data_Monoid from "../Data.Monoid/index.js";

16+import * as Data_Newtype from "../Data.Newtype/index.js";

17+import * as Data_Traversable from "../Data.Traversable/index.js";

18+import * as Data_Tuple from "../Data.Tuple/index.js";

19+import * as Data_Unit from "../Data.Unit/index.js";

20+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

21+var traverse = /* #__PURE__ */ Data_Traversable.traverse(Data_Traversable.traversableArray);

22+var traverse1 = /* #__PURE__ */ Data_Traversable.traverse(Data_Traversable.traversableTuple);

23+var traverse2 = /* #__PURE__ */ Data_Traversable.traverse(Data_Traversable.traversableMaybe);

24+var ltraverse = /* #__PURE__ */ Data_Bitraversable.ltraverse(Data_Bitraversable.bitraversableTuple);

25+var traverse3 = /* #__PURE__ */ Data_Traversable.traverse(Data_Array_NonEmpty_Internal.traversableNonEmptyArray);

26+var bitraverse = /* #__PURE__ */ Data_Bitraversable.bitraverse(Data_Bitraversable.bitraversableTuple);

27+var bind = /* #__PURE__ */ Control_Bind.bind(Data_Identity.bindIdentity);

28+var pure = /* #__PURE__ */ Control_Applicative.pure(Data_Identity.applicativeIdentity);

29+var applicativeReaderT = /* #__PURE__ */ Control_Monad_Reader_Trans.applicativeReaderT(Data_Identity.applicativeIdentity);

30+var bind1 = /* #__PURE__ */ Control_Bind.bind(Control_Monad_Free.freeBind);

31+var pure1 = /* #__PURE__ */ Control_Applicative.pure(Control_Monad_Free.freeApplicative);

32+var un = /* #__PURE__ */ Data_Newtype.un();

33+var runFree = /* #__PURE__ */ Control_Monad_Free.runFree(Data_Identity.functorIdentity);

34+var applyCompose = /* #__PURE__ */ Data_Functor_Compose.applyCompose(Control_Monad_Free.freeApply);

35+var applicativeCompose = /* #__PURE__ */ Data_Functor_Compose.applicativeCompose(Control_Monad_Free.freeApplicative);

36+var identity = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);

37+var bindFlipped = /* #__PURE__ */ Control_Bind.bindFlipped(Control_Monad_Free.freeBind);

38+var traverseWrapped = function (dictApplicative) {

39+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

40+ return function (k) {

41+ return function (v) {

42+ return map(function (value) {

43+ return {

44+ open: v.open,

45+ close: v.close,

46+ value: value

47+ };

48+ })(k(v.value));

49+ };

50+ };

51+};

52+var traverseSeparated = function (dictApplicative) {

53+ var Apply0 = dictApplicative.Apply0();

54+ var apply = Control_Apply.apply(Apply0);

55+ var map = Data_Functor.map(Apply0.Functor0());

56+ var traverse4 = traverse(dictApplicative);

57+ var traverse5 = traverse1(dictApplicative);

58+ return function (k) {

59+ return function (v) {

60+ return apply(map(function (v1) {

61+ return function (v2) {

62+ return {

63+ head: v1,

64+ tail: v2

65+ };

66+ };

67+ })(k(v.head)))(traverse4(traverse5(k))(v.tail));

68+ };

69+ };

70+};

71+var traverseRecordUpdate = function (dictApplicative) {

72+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

73+ var traverseWrapped1 = traverseWrapped(dictApplicative);

74+ var traverseSeparated1 = traverseSeparated(dictApplicative);

75+ return function (k) {

76+ return function (v) {

77+ if (v instanceof PureScript_CST_Types.RecordUpdateLeaf) {

78+ return map(PureScript_CST_Types.RecordUpdateLeaf.create(v.value0)(v.value1))(k.onExpr(v.value2));

79+ };

80+ if (v instanceof PureScript_CST_Types.RecordUpdateBranch) {

81+ return map(PureScript_CST_Types.RecordUpdateBranch.create(v.value0))(traverseWrapped1(traverseSeparated1(traverseRecordUpdate(dictApplicative)(k)))(v.value1));

82+ };

83+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 419, column 26 - line 421, column 146): " + [ v.constructor.name ]);

84+ };

85+ };

86+};

87+var traverseRecordLabeled = function (dictApplicative) {

88+ var pure2 = Control_Applicative.pure(dictApplicative);

89+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

90+ return function (k) {

91+ return function (v) {

92+ if (v instanceof PureScript_CST_Types.RecordPun) {

93+ return pure2(new PureScript_CST_Types.RecordPun(v.value0));

94+ };

95+ if (v instanceof PureScript_CST_Types.RecordField) {

96+ return map(PureScript_CST_Types.RecordField.create(v.value0)(v.value1))(k(v.value2));

97+ };

98+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 394, column 27 - line 396, column 57): " + [ v.constructor.name ]);

99+ };

100+ };

101+};

102+var traverseRecordAccessor = function (dictApplicative) {

103+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

104+ return function (k) {

105+ return function (r) {

106+ return map(function (v) {

107+ return {

108+ dot: r.dot,

109+ path: r.path,

110+ expr: v

111+ };

112+ })(k.onExpr(r.expr));

113+ };

114+ };

115+};

116+var traversePatternGuard = function (dictApplicative) {

117+ var Apply0 = dictApplicative.Apply0();

118+ var apply = Control_Apply.apply(Apply0);

119+ var map = Data_Functor.map(Apply0.Functor0());

120+ var traverse4 = traverse2(dictApplicative);

121+ var ltraverse1 = ltraverse(dictApplicative);

122+ return function (k) {

123+ return function (v) {

124+ return apply(map(function (binder) {

125+ return function (expr) {

126+ return {

127+ binder: binder,

128+ expr: expr

129+ };

130+ };

131+ })(traverse4(ltraverse1(k.onBinder))(v.binder)))(k.onExpr(v.expr));

132+ };

133+ };

134+};

135+var traverseModuleBody = function (dictApplicative) {

136+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

137+ var traverse4 = traverse(dictApplicative);

138+ return function (k) {

139+ return function (v) {

140+ return map(function (decls) {

141+ return {

142+ trailingComments: v.trailingComments,

143+ end: v.end,

144+ decls: decls

145+ };

146+ })(traverse4(k.onDecl)(v.decls));

147+ };

148+ };

149+};

150+var traverseModule = function (dictApplicative) {

151+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

152+ var traverseModuleBody1 = traverseModuleBody(dictApplicative);

153+ return function (k) {

154+ return function (v) {

155+ return map(function (body) {

156+ return {

157+ header: v.header,

158+ body: body

159+ };

160+ })(traverseModuleBody1(k)(v.body));

161+ };

162+ };

163+};

164+var traverseModule1 = /* #__PURE__ */ traverseModule(Control_Monad_Free.freeApplicative);

165+var traverseLambda = function (dictApplicative) {

166+ var Apply0 = dictApplicative.Apply0();

167+ var apply = Control_Apply.apply(Apply0);

168+ var map = Data_Functor.map(Apply0.Functor0());

169+ var traverse4 = traverse3(dictApplicative);

170+ return function (k) {

171+ return function (l) {

172+ return apply(map(function (v) {

173+ return function (v1) {

174+ return {

175+ arrow: l.arrow,

176+ symbol: l.symbol,

177+ binders: v,

178+ body: v1

179+ };

180+ };

181+ })(traverse4(k.onBinder)(l.binders)))(k.onExpr(l.body));

182+ };

183+ };

184+};

185+var traverseLabeled = function (dictApplicative) {

186+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

187+ return function (k) {

188+ return function (v) {

189+ return map(function (value) {

190+ return {

191+ label: v.label,

192+ separator: v.separator,

193+ value: value

194+ };

195+ })(k(v.value));

196+ };

197+ };

198+};

199+var traverseRow = function (dictApplicative) {

200+ var Apply0 = dictApplicative.Apply0();

201+ var apply = Control_Apply.apply(Apply0);

202+ var map = Data_Functor.map(Apply0.Functor0());

203+ var traverse4 = traverse2(dictApplicative);

204+ var traverseSeparated1 = traverseSeparated(dictApplicative);

205+ var traverseLabeled1 = traverseLabeled(dictApplicative);

206+ var traverse5 = traverse1(dictApplicative);

207+ return function (k) {

208+ return function (v) {

209+ return apply(map(function (labels) {

210+ return function (tail) {

211+ return {

212+ labels: labels,

213+ tail: tail

214+ };

215+ };

216+ })(traverse4(traverseSeparated1(traverseLabeled1(k.onType)))(v.labels)))(traverse4(traverse5(k.onType))(v.tail));

217+ };

218+ };

219+};

220+var traverseTypeVarBinding = function (dictApplicative) {

221+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

222+ var traverseWrapped1 = traverseWrapped(dictApplicative);

223+ var traverseLabeled1 = traverseLabeled(dictApplicative);

224+ var pure2 = Control_Applicative.pure(dictApplicative);

225+ return function (k) {

226+ return function (v) {

227+ if (v instanceof PureScript_CST_Types.TypeVarKinded) {

228+ return map(PureScript_CST_Types.TypeVarKinded.create)(traverseWrapped1(traverseLabeled1(k.onType))(v.value0));

229+ };

230+ if (v instanceof PureScript_CST_Types.TypeVarName) {

231+ return pure2(new PureScript_CST_Types.TypeVarName(v.value0));

232+ };

233+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 320, column 28 - line 322, column 46): " + [ v.constructor.name ]);

234+ };

235+ };

236+};

237+var traverseType = function (dictApplicative) {

238+ var Apply0 = dictApplicative.Apply0();

239+ var Functor0 = Apply0.Functor0();

240+ var map = Data_Functor.map(Functor0);

241+ var traverseWrapped1 = traverseWrapped(dictApplicative);

242+ var traverseRow1 = traverseRow(dictApplicative);

243+ var apply = Control_Apply.apply(Apply0);

244+ var flap = Data_Functor.flap(Functor0);

245+ var traverse4 = traverse3(dictApplicative);

246+ var traverseTypeVarBinding1 = traverseTypeVarBinding(dictApplicative);

247+ var traverse5 = traverse1(dictApplicative);

248+ var pure2 = Control_Applicative.pure(dictApplicative);

249+ return function (k) {

250+ return function (v) {

251+ if (v instanceof PureScript_CST_Types.TypeRow) {

252+ return map(PureScript_CST_Types.TypeRow.create)(traverseWrapped1(traverseRow1(k))(v.value0));

253+ };

254+ if (v instanceof PureScript_CST_Types.TypeRecord) {

255+ return map(PureScript_CST_Types.TypeRecord.create)(traverseWrapped1(traverseRow1(k))(v.value0));

256+ };

257+ if (v instanceof PureScript_CST_Types.TypeForall) {

258+ return apply(flap(map(PureScript_CST_Types.TypeForall.create(v.value0))(traverse4(traverseTypeVarBinding1(k))(v.value1)))(v.value2))(k.onType(v.value3));

259+ };

260+ if (v instanceof PureScript_CST_Types.TypeKinded) {

261+ return apply(flap(map(PureScript_CST_Types.TypeKinded.create)(k.onType(v.value0)))(v.value1))(k.onType(v.value2));

262+ };

263+ if (v instanceof PureScript_CST_Types.TypeApp) {

264+ return apply(map(PureScript_CST_Types.TypeApp.create)(k.onType(v.value0)))(traverse4(k.onType)(v.value1));

265+ };

266+ if (v instanceof PureScript_CST_Types.TypeOp) {

267+ return apply(map(PureScript_CST_Types.TypeOp.create)(k.onType(v.value0)))(traverse4(traverse5(k.onType))(v.value1));

268+ };

269+ if (v instanceof PureScript_CST_Types.TypeArrow) {

270+ return apply(flap(map(PureScript_CST_Types.TypeArrow.create)(k.onType(v.value0)))(v.value1))(k.onType(v.value2));

271+ };

272+ if (v instanceof PureScript_CST_Types.TypeConstrained) {

273+ return apply(flap(map(PureScript_CST_Types.TypeConstrained.create)(k.onType(v.value0)))(v.value1))(k.onType(v.value2));

274+ };

275+ if (v instanceof PureScript_CST_Types.TypeParens) {

276+ return map(PureScript_CST_Types.TypeParens.create)(traverseWrapped1(k.onType)(v.value0));

277+ };

278+ return pure2(v);

279+ };

280+ };

281+};

282+var traverseType1 = /* #__PURE__ */ traverseType(applicativeReaderT);

283+var traverseType2 = /* #__PURE__ */ traverseType(Control_Monad_Free.freeApplicative);

284+var traverseIfThenElse = function (dictApplicative) {

285+ var Apply0 = dictApplicative.Apply0();

286+ var apply = Control_Apply.apply(Apply0);

287+ var map = Data_Functor.map(Apply0.Functor0());

288+ return function (k) {

289+ return function (r) {

290+ return apply(apply(map(function (v) {

291+ return function (v1) {

292+ return function (v2) {

293+ return {

294+ "else": r["else"],

295+ keyword: r.keyword,

296+ then: r.then,

297+ cond: v,

298+ "true": v1,

299+ "false": v2

300+ };

301+ };

302+ };

303+ })(k.onExpr(r.cond)))(k.onExpr(r["true"])))(k.onExpr(r["false"]));

304+ };

305+ };

306+};

307+var traverseWhere = function (dictApplicative) {

308+ var Apply0 = dictApplicative.Apply0();

309+ var apply = Control_Apply.apply(Apply0);

310+ var map = Data_Functor.map(Apply0.Functor0());

311+ var traverse4 = traverse2(dictApplicative);

312+ var traverse5 = traverse1(dictApplicative);

313+ var traverse6 = traverse3(dictApplicative);

314+ return function (k) {

315+ return function (v) {

316+ return apply(map(function (expr) {

317+ return function (bindings) {

318+ return {

319+ expr: expr,

320+ bindings: bindings

321+ };

322+ };

323+ })(k.onExpr(v.expr)))(traverse4(traverse5(traverse6(traverseLetBinding(dictApplicative)(k))))(v.bindings));

324+ };

325+ };

326+};

327+var traverseValueBindingFields = function (dictApplicative) {

328+ var Apply0 = dictApplicative.Apply0();

329+ var apply = Control_Apply.apply(Apply0);

330+ var map = Data_Functor.map(Apply0.Functor0());

331+ var traverse4 = traverse(dictApplicative);

332+ return function (k) {

333+ return function (v) {

334+ return apply(map(function (v1) {

335+ return function (v2) {

336+ return {

337+ name: v.name,

338+ binders: v1,

339+ guarded: v2

340+ };

341+ };

342+ })(traverse4(k.onBinder)(v.binders)))(traverseGuarded(dictApplicative)(k)(v.guarded));

343+ };

344+ };

345+};

346+var traverseLetBinding = function (dictApplicative) {

347+ var Apply0 = dictApplicative.Apply0();

348+ var Functor0 = Apply0.Functor0();

349+ var map = Data_Functor.map(Functor0);

350+ var traverseLabeled1 = traverseLabeled(dictApplicative);

351+ var apply = Control_Apply.apply(Apply0);

352+ var flap = Data_Functor.flap(Functor0);

353+ var pure2 = Control_Applicative.pure(dictApplicative);

354+ return function (k) {

355+ return function (v) {

356+ if (v instanceof PureScript_CST_Types.LetBindingSignature) {

357+ return map(PureScript_CST_Types.LetBindingSignature.create)(traverseLabeled1(k.onType)(v.value0));

358+ };

359+ if (v instanceof PureScript_CST_Types.LetBindingName) {

360+ return map(PureScript_CST_Types.LetBindingName.create)(traverseValueBindingFields(dictApplicative)(k)(v.value0));

361+ };

362+ if (v instanceof PureScript_CST_Types.LetBindingPattern) {

363+ return apply(flap(map(PureScript_CST_Types.LetBindingPattern.create)(k.onBinder(v.value0)))(v.value1))(traverseWhere(dictApplicative)(k)(v.value2));

364+ };

365+ if (v instanceof PureScript_CST_Types.LetBindingError) {

366+ return pure2(new PureScript_CST_Types.LetBindingError(v.value0));

367+ };

368+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 498, column 24 - line 502, column 48): " + [ v.constructor.name ]);

369+ };

370+ };

371+};

372+var traverseGuardedExpr = function (dictApplicative) {

373+ var Apply0 = dictApplicative.Apply0();

374+ var apply = Control_Apply.apply(Apply0);

375+ var map = Data_Functor.map(Apply0.Functor0());

376+ var traverseSeparated1 = traverseSeparated(dictApplicative);

377+ var traversePatternGuard1 = traversePatternGuard(dictApplicative);

378+ return function (k) {

379+ return function (v) {

380+ return apply(map(function (ps) {

381+ return function (wh) {

382+ return {

383+ bar: v.bar,

384+ separator: v.separator,

385+ patterns: ps,

386+ where: wh

387+ };

388+ };

389+ })(traverseSeparated1(traversePatternGuard1(k))(v.patterns)))(traverseWhere(dictApplicative)(k)(v.where));

390+ };

391+ };

392+};

393+var traverseGuarded = function (dictApplicative) {

394+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

395+ var traverse4 = traverse3(dictApplicative);

396+ return function (k) {

397+ return function (v) {

398+ if (v instanceof PureScript_CST_Types.Unconditional) {

399+ return map(PureScript_CST_Types.Unconditional.create(v.value0))(traverseWhere(dictApplicative)(k)(v.value1));

400+ };

401+ if (v instanceof PureScript_CST_Types.Guarded) {

402+ return map(PureScript_CST_Types.Guarded.create)(traverse4(traverseGuardedExpr(dictApplicative)(k))(v.value0));

403+ };

404+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 459, column 21 - line 461, column 72): " + [ v.constructor.name ]);

405+ };

406+ };

407+};

408+var traverseInstanceBinding = function (dictApplicative) {

409+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

410+ var traverseLabeled1 = traverseLabeled(dictApplicative);

411+ var traverseValueBindingFields1 = traverseValueBindingFields(dictApplicative);

412+ return function (k) {

413+ return function (v) {

414+ if (v instanceof PureScript_CST_Types.InstanceBindingSignature) {

415+ return map(PureScript_CST_Types.InstanceBindingSignature.create)(traverseLabeled1(k.onType)(v.value0));

416+ };

417+ if (v instanceof PureScript_CST_Types.InstanceBindingName) {

418+ return map(PureScript_CST_Types.InstanceBindingName.create)(traverseValueBindingFields1(k)(v.value0));

419+ };

420+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 247, column 29 - line 249, column 92): " + [ v.constructor.name ]);

421+ };

422+ };

423+};

424+var traverseLetIn = function (dictApplicative) {

425+ var Apply0 = dictApplicative.Apply0();

426+ var apply = Control_Apply.apply(Apply0);

427+ var map = Data_Functor.map(Apply0.Functor0());

428+ var traverse4 = traverse3(dictApplicative);

429+ var traverseLetBinding1 = traverseLetBinding(dictApplicative);

430+ return function (k) {

431+ return function (l) {

432+ return apply(map(function (v) {

433+ return function (v1) {

434+ return {

435+ "in": l["in"],

436+ keyword: l.keyword,

437+ bindings: v,

438+ body: v1

439+ };

440+ };

441+ })(traverse4(traverseLetBinding1(k))(l.bindings)))(k.onExpr(l.body));

442+ };

443+ };

444+};

445+var traverseForeign = function (dictApplicative) {

446+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

447+ var traverseLabeled1 = traverseLabeled(dictApplicative);

448+ var pure2 = Control_Applicative.pure(dictApplicative);

449+ return function (k) {

450+ return function (v) {

451+ if (v instanceof PureScript_CST_Types.ForeignValue) {

452+ return map(PureScript_CST_Types.ForeignValue.create)(traverseLabeled1(k.onType)(v.value0));

453+ };

454+ if (v instanceof PureScript_CST_Types.ForeignData) {

455+ return map(PureScript_CST_Types.ForeignData.create(v.value0))(traverseLabeled1(k.onType)(v.value1));

456+ };

457+ if (v instanceof PureScript_CST_Types.ForeignKind) {

458+ return pure2(v);

459+ };

460+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 217, column 21 - line 220, column 40): " + [ v.constructor.name ]);

461+ };

462+ };

463+};

464+var traverseExprAppSpine = function (dictApplicative) {

465+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

466+ return function (k) {

467+ return function (v) {

468+ if (v instanceof PureScript_CST_Types.AppType) {

469+ return map(PureScript_CST_Types.AppType.create(v.value0))(k.onType(v.value1));

470+ };

471+ if (v instanceof PureScript_CST_Types.AppTerm) {

472+ return map(PureScript_CST_Types.AppTerm.create)(k.onExpr(v.value0));

473+ };

474+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 353, column 26 - line 355, column 44): " + [ v.constructor.name ]);

475+ };

476+ };

477+};

478+var traverseDoStatement = function (dictApplicative) {

479+ var Apply0 = dictApplicative.Apply0();

480+ var Functor0 = Apply0.Functor0();

481+ var map = Data_Functor.map(Functor0);

482+ var traverse4 = traverse3(dictApplicative);

483+ var traverseLetBinding1 = traverseLetBinding(dictApplicative);

484+ var apply = Control_Apply.apply(Apply0);

485+ var flap = Data_Functor.flap(Functor0);

486+ var pure2 = Control_Applicative.pure(dictApplicative);

487+ return function (k) {

488+ return function (v) {

489+ if (v instanceof PureScript_CST_Types.DoLet) {

490+ return map(PureScript_CST_Types.DoLet.create(v.value0))(traverse4(traverseLetBinding1(k))(v.value1));

491+ };

492+ if (v instanceof PureScript_CST_Types.DoDiscard) {

493+ return map(PureScript_CST_Types.DoDiscard.create)(k.onExpr(v.value0));

494+ };

495+ if (v instanceof PureScript_CST_Types.DoBind) {

496+ return apply(flap(map(PureScript_CST_Types.DoBind.create)(k.onBinder(v.value0)))(v.value1))(k.onExpr(v.value2));

497+ };

498+ if (v instanceof PureScript_CST_Types.DoError) {

499+ return pure2(new PureScript_CST_Types.DoError(v.value0));

500+ };

501+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 529, column 25 - line 533, column 32): " + [ v.constructor.name ]);

502+ };

503+ };

504+};

505+var traverseDoBlock = function (dictApplicative) {

506+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

507+ var traverse4 = traverse3(dictApplicative);

508+ var traverseDoStatement1 = traverseDoStatement(dictApplicative);

509+ return function (k) {

510+ return function (d) {

511+ return map(function (v) {

512+ return {

513+ keyword: d.keyword,

514+ statements: v

515+ };

516+ })(traverse4(traverseDoStatement1(k))(d.statements));

517+ };

518+ };

519+};

520+var traverseDelimitedNonEmpty = function (dictApplicative) {

521+ var traverseWrapped1 = traverseWrapped(dictApplicative);

522+ var traverseSeparated1 = traverseSeparated(dictApplicative);

523+ return function (k) {

524+ return traverseWrapped1(traverseSeparated1(k));

525+ };

526+};

527+var traverseOneOrDelimited = function (dictApplicative) {

528+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

529+ var traverseDelimitedNonEmpty1 = traverseDelimitedNonEmpty(dictApplicative);

530+ return function (k) {

531+ return function (v) {

532+ if (v instanceof PureScript_CST_Types.One) {

533+ return map(PureScript_CST_Types.One.create)(k(v.value0));

534+ };

535+ if (v instanceof PureScript_CST_Types.Many) {

536+ return map(PureScript_CST_Types.Many.create)(traverseDelimitedNonEmpty1(k)(v.value0));

537+ };

538+ throw new Error("Failed pattern match at PureScript.CST.Traversal (line 266, column 28 - line 268, column 55): " + [ v.constructor.name ]);

539+ };

540+ };

541+};

542+var traverseInstanceHead = function (dictApplicative) {

543+ var Apply0 = dictApplicative.Apply0();

544+ var apply = Control_Apply.apply(Apply0);

545+ var map = Data_Functor.map(Apply0.Functor0());

546+ var traverse4 = traverse2(dictApplicative);

547+ var ltraverse1 = ltraverse(dictApplicative);

548+ var traverseOneOrDelimited1 = traverseOneOrDelimited(dictApplicative);

549+ var traverse5 = traverse(dictApplicative);

550+ return function (k) {

551+ return function (head) {

552+ return apply(map(function (v) {

553+ return function (v1) {

554+ return {

555+ className: head.className,

556+ keyword: head.keyword,

557+ name: head.name,

558+ constraints: v,

559+ types: v1

560+ };

561+ };

562+ })(traverse4(ltraverse1(traverseOneOrDelimited1(k.onType)))(head.constraints)))(traverse5(k.onType)(head.types));

563+ };

564+ };

565+};

566+var traverseInstance = function (dictApplicative) {

567+ var Apply0 = dictApplicative.Apply0();

568+ var apply = Control_Apply.apply(Apply0);

569+ var map = Data_Functor.map(Apply0.Functor0());

570+ var traverseInstanceHead1 = traverseInstanceHead(dictApplicative);

571+ var traverse4 = traverse2(dictApplicative);

572+ var traverse5 = traverse1(dictApplicative);

573+ var traverse6 = traverse3(dictApplicative);

574+ var traverseInstanceBinding1 = traverseInstanceBinding(dictApplicative);

575+ return function (k) {

576+ return function (v) {

577+ return apply(map(function (head) {

578+ return function (body) {

579+ return {

580+ head: head,

581+ body: body

582+ };

583+ };

584+ })(traverseInstanceHead1(k)(v.head)))(traverse4(traverse5(traverse6(traverseInstanceBinding1(k))))(v.body));

585+ };

586+ };

587+};

588+var traverseDelimited = function (dictApplicative) {

589+ var traverseWrapped1 = traverseWrapped(dictApplicative);

590+ var traverse4 = traverse2(dictApplicative);

591+ var traverseSeparated1 = traverseSeparated(dictApplicative);

592+ return function (k) {

593+ return traverseWrapped1(traverse4(traverseSeparated1(k)));

594+ };

595+};

596+var traverseDataHead = function (dictApplicative) {

597+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

598+ var traverse4 = traverse(dictApplicative);

599+ var traverseTypeVarBinding1 = traverseTypeVarBinding(dictApplicative);

600+ return function (k) {

601+ return function (head) {

602+ return map(function (v) {

603+ return {

604+ keyword: head.keyword,

605+ name: head.name,

606+ vars: v

607+ };

608+ })(traverse4(traverseTypeVarBinding1(k))(head.vars));

609+ };

610+ };

611+};

612+var traverseDataCtor = function (dictApplicative) {

613+ var map = Data_Functor.map((dictApplicative.Apply0()).Functor0());

614+ var traverse4 = traverse(dictApplicative);

615+ return function (k) {

616+ return function (v) {

617+ return map(function (fields) {

618+ return {

619+ name: v.name,

620+ fields: fields

621+ };

622+ })(traverse4(k.onType)(v.fields));

623+ };

624+ };

625+};

626+var traverseClassHead = function (dictApplicative) {

627+ var Apply0 = dictApplicative.Apply0();

628+ var apply = Control_Apply.apply(Apply0);

629+ var map = Data_Functor.map(Apply0.Functor0());

630+ var traverse4 = traverse2(dictApplicative);

631+ var ltraverse1 = ltraverse(dictApplicative);

632+ var traverseOneOrDelimited1 = traverseOneOrDelimited(dictApplicative);

633+ var traverse5 = traverse(dictApplicative);

634+ var traverseTypeVarBinding1 = traverseTypeVarBinding(dictApplicative);

635+ return function (k) {

636+ return function (head) {

637+ return apply(map(function (v) {

638+ return function (v1) {

639+ return {

640+ fundeps: head.fundeps,

641+ keyword: head.keyword,

642+ name: head.name,

643+ "super": v,

644+ vars: v1

645+ };

646+ };

647+ })(traverse4(ltraverse1(traverseOneOrDelimited1(k.onType)))(head["super"])))(traverse5(traverseTypeVarBinding1(k))(head.vars));

648+ };

649+ };

650+};

651+var traverseDecl = function (dictApplicative) {

652+ var Apply0 = dictApplicative.Apply0();

653+ var apply = Control_Apply.apply(Apply0);

654+ var Functor0 = Apply0.Functor0();

655+ var map = Data_Functor.map(Functor0);

656+ var traverseDataHead1 = traverseDataHead(dictApplicative);

657+ var traverse4 = traverse2(dictApplicative);

658+ var traverse5 = traverse1(dictApplicative);

659+ var traverseSeparated1 = traverseSeparated(dictApplicative);

660+ var traverseDataCtor1 = traverseDataCtor(dictApplicative);

661+ var flap = Data_Functor.flap(Functor0);

662+ var traverseClassHead1 = traverseClassHead(dictApplicative);

663+ var traverse6 = traverse3(dictApplicative);

664+ var traverseLabeled1 = traverseLabeled(dictApplicative);

665+ var traverseInstance1 = traverseInstance(dictApplicative);

666+ var traverseInstanceHead1 = traverseInstanceHead(dictApplicative);

667+ var traverseValueBindingFields1 = traverseValueBindingFields(dictApplicative);

668+ var traverseForeign1 = traverseForeign(dictApplicative);

669+ var pure2 = Control_Applicative.pure(dictApplicative);

670+ return function (k) {

671+ return function (v) {

672+ if (v instanceof PureScript_CST_Types.DeclData) {

673+ return apply(map(PureScript_CST_Types.DeclData.create)(traverseDataHead1(k)(v.value0)))(traverse4(traverse5(traverseSeparated1(traverseDataCtor1(k))))(v.value1));

674+ };

675+ if (v instanceof PureScript_CST_Types.DeclType) {

676+ return apply(flap(map(PureScript_CST_Types.DeclType.create)(traverseDataHead1(k)(v.value0)))(v.value1))(k.onType(v.value2));

677+ };

678+ if (v instanceof PureScript_CST_Types.DeclNewtype) {

679+ return apply(flap(flap(map(PureScript_CST_Types.DeclNewtype.create)(traverseDataHead1(k)(v.value0)))(v.value1))(v.value2))(k.onType(v.value3));

680+ };

681+ if (v instanceof PureScript_CST_Types.DeclClass) {

682+ return apply(map(PureScript_CST_Types.DeclClass.create)(traverseClassHead1(k)(v.value0)))(traverse4(traverse5(traverse6(traverseLabeled1(k.onType))))(v.value1));

683+ };

684+ if (v instanceof PureScript_CST_Types.DeclInstanceChain) {

685+ return map(PureScript_CST_Types.DeclInstanceChain.create)(traverseSeparated1(traverseInstance1(k))(v.value0));

686+ };

687+ if (v instanceof PureScript_CST_Types.DeclDerive) {

688+ return map(PureScript_CST_Types.DeclDerive.create(v.value0)(v.value1))(traverseInstanceHead1(k)(v.value2));

689+ };

690+ if (v instanceof PureScript_CST_Types.DeclKindSignature) {

691+ return map(PureScript_CST_Types.DeclKindSignature.create(v.value0))(traverseLabeled1(k.onType)(v.value1));

692+ };

693+ if (v instanceof PureScript_CST_Types.DeclSignature) {

694+ return map(PureScript_CST_Types.DeclSignature.create)(traverseLabeled1(k.onType)(v.value0));

695+ };

696+ if (v instanceof PureScript_CST_Types.DeclValue) {

697+ return map(PureScript_CST_Types.DeclValue.create)(traverseValueBindingFields1(k)(v.value0));

698+ };

699+ if (v instanceof PureScript_CST_Types.DeclForeign) {

700+ return map(PureScript_CST_Types.DeclForeign.create(v.value0)(v.value1))(traverseForeign1(k)(v.value2));

701+ };

702+ return pure2(v);

703+ };

704+ };

705+};

706+var traverseDecl1 = /* #__PURE__ */ traverseDecl(applicativeReaderT);

707+var traverseDecl2 = /* #__PURE__ */ traverseDecl(Control_Monad_Free.freeApplicative);

708+var traverseCaseOf = function (dictApplicative) {

709+ var Apply0 = dictApplicative.Apply0();

710+ var apply = Control_Apply.apply(Apply0);

711+ var map = Data_Functor.map(Apply0.Functor0());

712+ var traverseSeparated1 = traverseSeparated(dictApplicative);

713+ var traverse4 = traverse3(dictApplicative);

714+ var bitraverse1 = bitraverse(dictApplicative);

715+ var traverseGuarded1 = traverseGuarded(dictApplicative);

716+ return function (k) {

717+ return function (r) {

718+ return apply(map(function (v) {

719+ return function (v1) {

720+ return {

721+ keyword: r.keyword,

722+ of: r.of,

723+ head: v,

724+ branches: v1

725+ };

726+ };

727+ })(traverseSeparated1(k.onExpr)(r.head)))(traverse4(bitraverse1(traverseSeparated1(k.onBinder))(traverseGuarded1(k)))(r.branches));

728+ };

729+ };

730+};

731+var traverseBinder = function (dictApplicative) {

732+ var Apply0 = dictApplicative.Apply0();

733+ var Functor0 = Apply0.Functor0();

734+ var map = Data_Functor.map(Functor0);

735+ var traverse4 = traverse(dictApplicative);

736+ var traverseDelimited1 = traverseDelimited(dictApplicative);

737+ var traverseRecordLabeled1 = traverseRecordLabeled(dictApplicative);

738+ var traverseWrapped1 = traverseWrapped(dictApplicative);

739+ var apply = Control_Apply.apply(Apply0);

740+ var flap = Data_Functor.flap(Functor0);

741+ var traverse5 = traverse3(dictApplicative);

742+ var traverse6 = traverse1(dictApplicative);

743+ var pure2 = Control_Applicative.pure(dictApplicative);

744+ return function (k) {

745+ return function (v) {

746+ if (v instanceof PureScript_CST_Types.BinderNamed) {

747+ return map(PureScript_CST_Types.BinderNamed.create(v.value0)(v.value1))(k.onBinder(v.value2));

748+ };

749+ if (v instanceof PureScript_CST_Types.BinderConstructor) {

750+ return map(PureScript_CST_Types.BinderConstructor.create(v.value0))(traverse4(k.onBinder)(v.value1));

751+ };

752+ if (v instanceof PureScript_CST_Types.BinderArray) {

753+ return map(PureScript_CST_Types.BinderArray.create)(traverseDelimited1(k.onBinder)(v.value0));

754+ };

755+ if (v instanceof PureScript_CST_Types.BinderRecord) {

756+ return map(PureScript_CST_Types.BinderRecord.create)(traverseDelimited1(traverseRecordLabeled1(k.onBinder))(v.value0));

757+ };

758+ if (v instanceof PureScript_CST_Types.BinderParens) {

759+ return map(PureScript_CST_Types.BinderParens.create)(traverseWrapped1(k.onBinder)(v.value0));

760+ };

761+ if (v instanceof PureScript_CST_Types.BinderTyped) {

762+ return apply(flap(map(PureScript_CST_Types.BinderTyped.create)(k.onBinder(v.value0)))(v.value1))(k.onType(v.value2));

763+ };

764+ if (v instanceof PureScript_CST_Types.BinderOp) {

765+ return apply(map(PureScript_CST_Types.BinderOp.create)(k.onBinder(v.value0)))(traverse5(traverse6(k.onBinder))(v.value1));

766+ };

767+ return pure2(v);

768+ };

769+ };

770+};

771+var traverseBinder1 = /* #__PURE__ */ traverseBinder(applicativeReaderT);

772+var traverseBinder2 = /* #__PURE__ */ traverseBinder(Control_Monad_Free.freeApplicative);

773+var traverseAdoBlock = function (dictApplicative) {

774+ var Apply0 = dictApplicative.Apply0();

775+ var apply = Control_Apply.apply(Apply0);

776+ var map = Data_Functor.map(Apply0.Functor0());

777+ var traverse4 = traverse(dictApplicative);

778+ var traverseDoStatement1 = traverseDoStatement(dictApplicative);

779+ return function (k) {

780+ return function (a) {

781+ return apply(map(function (v) {

782+ return function (v1) {

783+ return {

784+ "in": a["in"],

785+ keyword: a.keyword,

786+ statements: v,

787+ result: v1

788+ };

789+ };

790+ })(traverse4(traverseDoStatement1(k))(a.statements)))(k.onExpr(a.result));

791+ };

792+ };

793+};

794+var traverseExpr = function (dictApplicative) {

795+ var Apply0 = dictApplicative.Apply0();

796+ var Functor0 = Apply0.Functor0();

797+ var map = Data_Functor.map(Functor0);

798+ var traverseDelimited1 = traverseDelimited(dictApplicative);

799+ var traverseRecordLabeled1 = traverseRecordLabeled(dictApplicative);

800+ var traverseWrapped1 = traverseWrapped(dictApplicative);

801+ var apply = Control_Apply.apply(Apply0);

802+ var flap = Data_Functor.flap(Functor0);

803+ var traverse4 = traverse3(dictApplicative);

804+ var bitraverse1 = bitraverse(dictApplicative);

805+ var traverse5 = traverse1(dictApplicative);

806+ var traverseRecordAccessor1 = traverseRecordAccessor(dictApplicative);

807+ var traverseSeparated1 = traverseSeparated(dictApplicative);

808+ var traverseRecordUpdate1 = traverseRecordUpdate(dictApplicative);

809+ var traverseExprAppSpine1 = traverseExprAppSpine(dictApplicative);

810+ var traverseLambda1 = traverseLambda(dictApplicative);

811+ var traverseIfThenElse1 = traverseIfThenElse(dictApplicative);

812+ var traverseCaseOf1 = traverseCaseOf(dictApplicative);

813+ var traverseLetIn1 = traverseLetIn(dictApplicative);

814+ var traverseDoBlock1 = traverseDoBlock(dictApplicative);

815+ var traverseAdoBlock1 = traverseAdoBlock(dictApplicative);

816+ var pure2 = Control_Applicative.pure(dictApplicative);

817+ return function (k) {

818+ return function (v) {

819+ if (v instanceof PureScript_CST_Types.ExprArray) {

820+ return map(PureScript_CST_Types.ExprArray.create)(traverseDelimited1(k.onExpr)(v.value0));

821+ };

822+ if (v instanceof PureScript_CST_Types.ExprRecord) {

823+ return map(PureScript_CST_Types.ExprRecord.create)(traverseDelimited1(traverseRecordLabeled1(k.onExpr))(v.value0));

824+ };

825+ if (v instanceof PureScript_CST_Types.ExprParens) {

826+ return map(PureScript_CST_Types.ExprParens.create)(traverseWrapped1(k.onExpr)(v.value0));

827+ };

828+ if (v instanceof PureScript_CST_Types.ExprTyped) {

829+ return apply(flap(map(PureScript_CST_Types.ExprTyped.create)(k.onExpr(v.value0)))(v.value1))(k.onType(v.value2));

830+ };

831+ if (v instanceof PureScript_CST_Types.ExprInfix) {

832+ return apply(map(PureScript_CST_Types.ExprInfix.create)(k.onExpr(v.value0)))(traverse4(bitraverse1(traverseWrapped1(k.onExpr))(k.onExpr))(v.value1));

833+ };

834+ if (v instanceof PureScript_CST_Types.ExprOp) {

835+ return apply(map(PureScript_CST_Types.ExprOp.create)(k.onExpr(v.value0)))(traverse4(traverse5(k.onExpr))(v.value1));

836+ };

837+ if (v instanceof PureScript_CST_Types.ExprNegate) {

838+ return map(PureScript_CST_Types.ExprNegate.create(v.value0))(k.onExpr(v.value1));

839+ };

840+ if (v instanceof PureScript_CST_Types.ExprRecordAccessor) {

841+ return map(PureScript_CST_Types.ExprRecordAccessor.create)(traverseRecordAccessor1(k)(v.value0));

842+ };

843+ if (v instanceof PureScript_CST_Types.ExprRecordUpdate) {

844+ return apply(map(PureScript_CST_Types.ExprRecordUpdate.create)(k.onExpr(v.value0)))(traverseWrapped1(traverseSeparated1(traverseRecordUpdate1(k)))(v.value1));

845+ };

846+ if (v instanceof PureScript_CST_Types.ExprApp) {

847+ return apply(map(PureScript_CST_Types.ExprApp.create)(k.onExpr(v.value0)))(traverse4(traverseExprAppSpine1(k))(v.value1));

848+ };

849+ if (v instanceof PureScript_CST_Types.ExprLambda) {

850+ return map(PureScript_CST_Types.ExprLambda.create)(traverseLambda1(k)(v.value0));

851+ };

852+ if (v instanceof PureScript_CST_Types.ExprIf) {

853+ return map(PureScript_CST_Types.ExprIf.create)(traverseIfThenElse1(k)(v.value0));

854+ };

855+ if (v instanceof PureScript_CST_Types.ExprCase) {

856+ return map(PureScript_CST_Types.ExprCase.create)(traverseCaseOf1(k)(v.value0));

857+ };

858+ if (v instanceof PureScript_CST_Types.ExprLet) {

859+ return map(PureScript_CST_Types.ExprLet.create)(traverseLetIn1(k)(v.value0));

860+ };

861+ if (v instanceof PureScript_CST_Types.ExprDo) {

862+ return map(PureScript_CST_Types.ExprDo.create)(traverseDoBlock1(k)(v.value0));

863+ };

864+ if (v instanceof PureScript_CST_Types.ExprAdo) {

865+ return map(PureScript_CST_Types.ExprAdo.create)(traverseAdoBlock1(k)(v.value0));

866+ };

867+ return pure2(v);

868+ };

869+ };

870+};

871+var traverseExpr1 = /* #__PURE__ */ traverseExpr(applicativeReaderT);

872+var traverseExpr2 = /* #__PURE__ */ traverseExpr(Control_Monad_Free.freeApplicative);

873+var topDownTraversalWithContextM = function (dictMonad) {

874+ var bind2 = Control_Bind.bind(dictMonad.Bind1());

875+ var applicativeReaderT1 = Control_Monad_Reader_Trans.applicativeReaderT(dictMonad.Applicative0());

876+ var traverseBinder3 = traverseBinder(applicativeReaderT1);

877+ var traverseExpr3 = traverseExpr(applicativeReaderT1);

878+ var traverseDecl3 = traverseDecl(applicativeReaderT1);

879+ var traverseType3 = traverseType(applicativeReaderT1);

880+ return function (visitor) {

881+ var visitor$prime = {

882+ onBinder: function (a) {

883+ return function (ctx) {

884+ return bind2(visitor.onBinder(ctx)(a))(Data_Tuple.uncurry(Data_Function.flip((function () {

885+ var $680 = traverseBinder3(visitor$prime);

886+ return function ($681) {

887+ return Control_Monad_Reader_Trans.runReaderT($680($681));

888+ };

889+ })())));

890+ };

891+ },

892+ onExpr: function (a) {

893+ return function (ctx) {

894+ return bind2(visitor.onExpr(ctx)(a))(Data_Tuple.uncurry(Data_Function.flip((function () {

895+ var $682 = traverseExpr3(visitor$prime);

896+ return function ($683) {

897+ return Control_Monad_Reader_Trans.runReaderT($682($683));

898+ };

899+ })())));

900+ };

901+ },

902+ onDecl: function (a) {

903+ return function (ctx) {

904+ return bind2(visitor.onDecl(ctx)(a))(Data_Tuple.uncurry(Data_Function.flip((function () {

905+ var $684 = traverseDecl3(visitor$prime);

906+ return function ($685) {

907+ return Control_Monad_Reader_Trans.runReaderT($684($685));

908+ };

909+ })())));

910+ };

911+ },

912+ onType: function (a) {

913+ return function (ctx) {

914+ return bind2(visitor.onType(ctx)(a))(Data_Tuple.uncurry(Data_Function.flip((function () {

915+ var $686 = traverseType3(visitor$prime);

916+ return function ($687) {

917+ return Control_Monad_Reader_Trans.runReaderT($686($687));

918+ };

919+ })())));

920+ };

921+ }

922+ };

923+ return visitor$prime;

924+ };

925+};

926+var topDownTraversalWithContext = function (visitor) {

927+ var visitor$prime = {

928+ onBinder: function (a) {

929+ return function (ctx) {

930+ return bind(pure(visitor.onBinder(ctx)(a)))(Data_Tuple.uncurry(Data_Function.flip((function () {

931+ var $688 = traverseBinder1(visitor$prime);

932+ return function ($689) {

933+ return Control_Monad_Reader_Trans.runReaderT($688($689));

934+ };

935+ })())));

936+ };

937+ },

938+ onExpr: function (a) {

939+ return function (ctx) {

940+ return bind(pure(visitor.onExpr(ctx)(a)))(Data_Tuple.uncurry(Data_Function.flip((function () {

941+ var $690 = traverseExpr1(visitor$prime);

942+ return function ($691) {

943+ return Control_Monad_Reader_Trans.runReaderT($690($691));

944+ };

945+ })())));

946+ };

947+ },

948+ onDecl: function (a) {

949+ return function (ctx) {

950+ return bind(pure(visitor.onDecl(ctx)(a)))(Data_Tuple.uncurry(Data_Function.flip((function () {

951+ var $692 = traverseDecl1(visitor$prime);

952+ return function ($693) {

953+ return Control_Monad_Reader_Trans.runReaderT($692($693));

954+ };

955+ })())));

956+ };

957+ },

958+ onType: function (a) {

959+ return function (ctx) {

960+ return bind(pure(visitor.onType(ctx)(a)))(Data_Tuple.uncurry(Data_Function.flip((function () {

961+ var $694 = traverseType1(visitor$prime);

962+ return function ($695) {

963+ return Control_Monad_Reader_Trans.runReaderT($694($695));

964+ };

965+ })())));

966+ };

967+ }

968+ };

969+ return visitor$prime;

970+};

971+var topDownTraversal = function (dictMonad) {

972+ var bind2 = Control_Bind.bind(dictMonad.Bind1());

973+ var Applicative0 = dictMonad.Applicative0();

974+ var traverseBinder3 = traverseBinder(Applicative0);

975+ var traverseExpr3 = traverseExpr(Applicative0);

976+ var traverseType3 = traverseType(Applicative0);

977+ var traverseDecl3 = traverseDecl(Applicative0);

978+ return function (visitor) {

979+ var visitor$prime = {

980+ onBinder: function (a) {

981+ return bind2(visitor.onBinder(a))(traverseBinder3(visitor$prime));

982+ },

983+ onExpr: function (a) {

984+ return bind2(visitor.onExpr(a))(traverseExpr3(visitor$prime));

985+ },

986+ onType: function (a) {

987+ return bind2(visitor.onType(a))(traverseType3(visitor$prime));

988+ },

989+ onDecl: function (a) {

990+ return bind2(visitor.onDecl(a))(traverseDecl3(visitor$prime));

991+ }

992+ };

993+ return visitor$prime;

994+ };

995+};

996+var topDownPureTraversal = function (visitor) {

997+ var visitor$prime = {

998+ onBinder: function (a) {

999+ return bind1(pure1(visitor.onBinder(a)))(traverseBinder2(visitor$prime));

1000+ },

1001+ onExpr: function (a) {

1002+ return bind1(pure1(visitor.onExpr(a)))(traverseExpr2(visitor$prime));

1003+ },

1004+ onType: function (a) {

1005+ return bind1(pure1(visitor.onType(a)))(traverseType2(visitor$prime));

1006+ },

1007+ onDecl: function (a) {

1008+ return bind1(pure1(visitor.onDecl(a)))(traverseDecl2(visitor$prime));

1009+ }

1010+ };

1011+ return visitor$prime;

1012+};

1013+var rewriteWithContextM = function (dictMonad) {

1014+ var topDownTraversalWithContextM1 = topDownTraversalWithContextM(dictMonad);

1015+ var map = Data_Functor.map(((dictMonad.Bind1()).Apply0()).Functor0());

1016+ return function (traversal) {

1017+ return function (visitor) {

1018+ return function (ctx) {

1019+ return function (g) {

1020+ var visitor$prime = topDownTraversalWithContextM1(visitor);

1021+ return map(Data_Tuple.Tuple.create(ctx))(Control_Monad_Reader_Trans.runReaderT(traversal(visitor$prime)(g))(ctx));

1022+ };

1023+ };

1024+ };

1025+ };

1026+};

1027+var rewriteWithContext = function (traversal) {

1028+ return function (visitor) {

1029+ return function (ctx) {

1030+ return function (g) {

1031+ var visitor$prime = topDownTraversalWithContext(visitor);

1032+ return new Data_Tuple.Tuple(ctx, un(Data_Identity.Identity)(Control_Monad_Reader_Trans.runReaderT(traversal(visitor$prime)(g))(ctx)));

1033+ };

1034+ };

1035+ };

1036+};

1037+var rewriteTypeWithContextM = function (dictMonad) {

1038+ return rewriteWithContextM(dictMonad)(function (v) {

1039+ return v.onType;

1040+ });

1041+};

1042+var rewriteTypeWithContext = /* #__PURE__ */ rewriteWithContext(function (v) {

1043+ return v.onType;

1044+});

1045+var rewriteTopDownM = function (dictMonad) {

1046+ var topDownTraversal1 = topDownTraversal(dictMonad);

1047+ return function (traversal) {

1048+ return function (visitor) {

1049+ var visitor$prime = topDownTraversal1(visitor);

1050+ return traversal(visitor$prime);

1051+ };

1052+ };

1053+};

1054+var rewriteTypeTopDownM = function (dictMonad) {

1055+ return rewriteTopDownM(dictMonad)(function (v) {

1056+ return v.onType;

1057+ });

1058+};

1059+var rewriteTopDown = function (traversal) {

1060+ return function (visitor) {

1061+ var visitor$prime = topDownPureTraversal(visitor);

1062+ var $696 = runFree(un(Data_Identity.Identity));

1063+ var $697 = traversal(visitor$prime);

1064+ return function ($698) {

1065+ return $696($697($698));

1066+ };

1067+ };

1068+};

1069+var rewriteTypeTopDown = /* #__PURE__ */ rewriteTopDown(function (v) {

1070+ return v.onType;

1071+});

1072+var rewriteModuleWithContextM = function (dictMonad) {

1073+ return rewriteWithContextM(dictMonad)(traverseModule(Control_Monad_Reader_Trans.applicativeReaderT(dictMonad.Applicative0())));

1074+};

1075+var rewriteModuleWithContext = /* #__PURE__ */ rewriteWithContext(/* #__PURE__ */ traverseModule(applicativeReaderT));

1076+var rewriteModuleTopDownM = function (dictMonad) {

1077+ return rewriteTopDownM(dictMonad)(traverseModule(dictMonad.Applicative0()));

1078+};

1079+var rewriteModuleTopDown = /* #__PURE__ */ rewriteTopDown(traverseModule1);

1080+var rewriteExprWithContextM = function (dictMonad) {

1081+ return rewriteWithContextM(dictMonad)(function (v) {

1082+ return v.onExpr;

1083+ });

1084+};

1085+var rewriteExprWithContext = /* #__PURE__ */ rewriteWithContext(function (v) {

1086+ return v.onExpr;

1087+});

1088+var rewriteExprTopDownM = function (dictMonad) {

1089+ return rewriteTopDownM(dictMonad)(function (v) {

1090+ return v.onExpr;

1091+ });

1092+};

1093+var rewriteExprTopDown = /* #__PURE__ */ rewriteTopDown(function (v) {

1094+ return v.onExpr;

1095+});

1096+var rewriteDeclWithContextM = function (dictMonad) {

1097+ return rewriteWithContextM(dictMonad)(function (v) {

1098+ return v.onDecl;

1099+ });

1100+};

1101+var rewriteDeclWithContext = /* #__PURE__ */ rewriteWithContext(function (v) {

1102+ return v.onDecl;

1103+});

1104+var rewriteDeclTopDownM = function (dictMonad) {

1105+ return rewriteTopDownM(dictMonad)(function (v) {

1106+ return v.onDecl;

1107+ });

1108+};

1109+var rewriteDeclTopDown = /* #__PURE__ */ rewriteTopDown(function (v) {

1110+ return v.onDecl;

1111+});

1112+var rewriteBinderWithContextM = function (dictMonad) {

1113+ return rewriteWithContextM(dictMonad)(function (v) {

1114+ return v.onBinder;

1115+ });

1116+};

1117+var rewriteBinderWithContext = /* #__PURE__ */ rewriteWithContext(function (v) {

1118+ return v.onBinder;

1119+});

1120+var rewriteBinderTopDownM = function (dictMonad) {

1121+ return rewriteTopDownM(dictMonad)(function (v) {

1122+ return v.onBinder;

1123+ });

1124+};

1125+var rewriteBinderTopDown = /* #__PURE__ */ rewriteTopDown(function (v) {

1126+ return v.onBinder;

1127+});

1128+var defer = function (dictMonad) {

1129+ var bind2 = Control_Bind.bind(dictMonad.Bind1());

1130+ var pure2 = Control_Applicative.pure(dictMonad.Applicative0());

1131+ return function (v) {

1132+ return bind2(pure2(Data_Unit.unit))(v);

1133+ };

1134+};

1135+var defer1 = /* #__PURE__ */ defer(Control_Monad_Free.freeMonad);

1136+var topDownMonoidalTraversal = function (dictMonoid) {

1137+ var apply = Control_Apply.apply(applyCompose(Data_Const.applyConst(dictMonoid.Semigroup0())));

1138+ var applicativeCompose1 = applicativeCompose(Data_Const.applicativeConst(dictMonoid));

1139+ var traverseBinder3 = traverseBinder(applicativeCompose1);

1140+ var traverseExpr3 = traverseExpr(applicativeCompose1);

1141+ var traverseDecl3 = traverseDecl(applicativeCompose1);

1142+ var traverseType3 = traverseType(applicativeCompose1);

1143+ return function (visitor) {

1144+ var visitor$prime = {

1145+ onBinder: function (a) {

1146+ return apply(pure1(visitor.onBinder(a)))(defer1(function (v) {

1147+ return un(Data_Functor_Compose.Compose)(traverseBinder3(visitor$prime)(a));

1148+ }));

1149+ },

1150+ onExpr: function (a) {

1151+ return apply(pure1(visitor.onExpr(a)))(defer1(function (v) {

1152+ return un(Data_Functor_Compose.Compose)(traverseExpr3(visitor$prime)(a));

1153+ }));

1154+ },

1155+ onDecl: function (a) {

1156+ return apply(pure1(visitor.onDecl(a)))(defer1(function (v) {

1157+ return un(Data_Functor_Compose.Compose)(traverseDecl3(visitor$prime)(a));

1158+ }));

1159+ },

1160+ onType: function (a) {

1161+ return apply(pure1(visitor.onType(a)))(defer1(function (v) {

1162+ return un(Data_Functor_Compose.Compose)(traverseType3(visitor$prime)(a));

1163+ }));

1164+ }

1165+ };

1166+ return visitor$prime;

1167+ };

1168+};

1169+var monoidalRewrite = function (dictMonoid) {

1170+ var topDownMonoidalTraversal1 = topDownMonoidalTraversal(dictMonoid);

1171+ return function (traversal) {

1172+ return function (visitor) {

1173+ return function (g) {

1174+ var visitor$prime = topDownMonoidalTraversal1(visitor);

1175+ return un(Data_Const.Const)(runFree(un(Data_Identity.Identity))(un(Data_Functor_Compose.Compose)(traversal(visitor$prime)(g))));

1176+ };

1177+ };

1178+ };

1179+};

1180+var foldMapBinder = function (dictMonoid) {

1181+ return monoidalRewrite(dictMonoid)(function (v) {

1182+ return v.onBinder;

1183+ });

1184+};

1185+var foldMapDecl = function (dictMonoid) {

1186+ return monoidalRewrite(dictMonoid)(function (v) {

1187+ return v.onDecl;

1188+ });

1189+};

1190+var foldMapExpr = function (dictMonoid) {

1191+ return monoidalRewrite(dictMonoid)(function (v) {

1192+ return v.onExpr;

1193+ });

1194+};

1195+var foldMapModule = function (dictMonoid) {

1196+ return monoidalRewrite(dictMonoid)(traverseModule(applicativeCompose(Data_Const.applicativeConst(dictMonoid))));

1197+};

1198+var foldMapType = function (dictMonoid) {

1199+ return monoidalRewrite(dictMonoid)(function (v) {

1200+ return v.onType;

1201+ });

1202+};

1203+var defaultVisitorWithContextM = function (dictMonad) {

1204+ var pure2 = Control_Applicative.pure(dictMonad.Applicative0());

1205+ return {

1206+ onBinder: Data_Tuple.curry(pure2),

1207+ onDecl: Data_Tuple.curry(pure2),

1208+ onExpr: Data_Tuple.curry(pure2),

1209+ onType: Data_Tuple.curry(pure2)

1210+ };

1211+};

1212+var defaultVisitorWithContext = {

1213+ onBinder: /* #__PURE__ */ Data_Tuple.curry(identity),

1214+ onDecl: /* #__PURE__ */ Data_Tuple.curry(identity),

1215+ onExpr: /* #__PURE__ */ Data_Tuple.curry(identity),

1216+ onType: /* #__PURE__ */ Data_Tuple.curry(identity)

1217+};

1218+var defaultVisitorM = function (dictApplicative) {

1219+ var pure2 = Control_Applicative.pure(dictApplicative);

1220+ return {

1221+ onBinder: pure2,

1222+ onDecl: pure2,

1223+ onExpr: pure2,

1224+ onType: pure2

1225+ };

1226+};

1227+var defaultVisitor = {

1228+ onBinder: identity,

1229+ onDecl: identity,

1230+ onExpr: identity,

1231+ onType: identity

1232+};

1233+var defaultMonoidalVisitor = function (dictMonoid) {

1234+ var mempty = Data_Monoid.mempty(Data_Monoid.monoidFn(dictMonoid));

1235+ return {

1236+ onBinder: mempty,

1237+ onDecl: mempty,

1238+ onExpr: mempty,

1239+ onType: mempty

1240+ };

1241+};

1242+var bottomUpTraversal = function (dictMonad) {

1243+ var bindFlipped1 = Control_Bind.bindFlipped(dictMonad.Bind1());

1244+ var defer2 = defer(dictMonad);

1245+ var Applicative0 = dictMonad.Applicative0();

1246+ var traverseBinder3 = traverseBinder(Applicative0);

1247+ var traverseExpr3 = traverseExpr(Applicative0);

1248+ var traverseType3 = traverseType(Applicative0);

1249+ var traverseDecl3 = traverseDecl(Applicative0);

1250+ return function (visitor) {

1251+ var visitor$prime = {

1252+ onBinder: function (a) {

1253+ return bindFlipped1(visitor.onBinder)(defer2(function (v) {

1254+ return traverseBinder3(visitor$prime)(a);

1255+ }));

1256+ },

1257+ onExpr: function (a) {

1258+ return bindFlipped1(visitor.onExpr)(defer2(function (v) {

1259+ return traverseExpr3(visitor$prime)(a);

1260+ }));

1261+ },

1262+ onType: function (a) {

1263+ return bindFlipped1(visitor.onType)(defer2(function (v) {

1264+ return traverseType3(visitor$prime)(a);

1265+ }));

1266+ },

1267+ onDecl: function (a) {

1268+ return bindFlipped1(visitor.onDecl)(defer2(function (v) {

1269+ return traverseDecl3(visitor$prime)(a);

1270+ }));

1271+ }

1272+ };

1273+ return visitor$prime;

1274+ };

1275+};

1276+var rewriteBottomUpM = function (dictMonad) {

1277+ var bottomUpTraversal1 = bottomUpTraversal(dictMonad);

1278+ return function (traversal) {

1279+ return function (visitor) {

1280+ var visitor$prime = bottomUpTraversal1(visitor);

1281+ return traversal(visitor$prime);

1282+ };

1283+ };

1284+};

1285+var rewriteBinderBottomUpM = function (dictMonad) {

1286+ return rewriteBottomUpM(dictMonad)(function (v) {

1287+ return v.onBinder;

1288+ });

1289+};

1290+var rewriteDeclBottomUpM = function (dictMonad) {

1291+ return rewriteBottomUpM(dictMonad)(function (v) {

1292+ return v.onDecl;

1293+ });

1294+};

1295+var rewriteExprBottomUpM = function (dictMonad) {

1296+ return rewriteBottomUpM(dictMonad)(function (v) {

1297+ return v.onExpr;

1298+ });

1299+};

1300+var rewriteModuleBottomUpM = function (dictMonad) {

1301+ return rewriteBottomUpM(dictMonad)(traverseModule(dictMonad.Applicative0()));

1302+};

1303+var rewriteTypeBottomUpM = function (dictMonad) {

1304+ return rewriteBottomUpM(dictMonad)(function (v) {

1305+ return v.onType;

1306+ });

1307+};

1308+var bottomUpPureTraversal = function (visitor) {

1309+ var visitor$prime = {

1310+ onBinder: function (a) {

1311+ return bindFlipped(function ($699) {

1312+ return pure1(visitor.onBinder($699));

1313+ })(traverseBinder2(visitor$prime)(a));

1314+ },

1315+ onExpr: function (a) {

1316+ return bindFlipped(function ($700) {

1317+ return pure1(visitor.onExpr($700));

1318+ })(traverseExpr2(visitor$prime)(a));

1319+ },

1320+ onType: function (a) {

1321+ return bindFlipped(function ($701) {

1322+ return pure1(visitor.onType($701));

1323+ })(traverseType2(visitor$prime)(a));

1324+ },

1325+ onDecl: function (a) {

1326+ return bindFlipped(function ($702) {

1327+ return pure1(visitor.onDecl($702));

1328+ })(traverseDecl2(visitor$prime)(a));

1329+ }

1330+ };

1331+ return visitor$prime;

1332+};

1333+var rewriteBottomUp = function (traversal) {

1334+ return function (visitor) {

1335+ var visitor$prime = bottomUpPureTraversal(visitor);

1336+ var $703 = runFree(un(Data_Identity.Identity));

1337+ var $704 = traversal(visitor$prime);

1338+ return function ($705) {

1339+ return $703($704($705));

1340+ };

1341+ };

1342+};

1343+var rewriteBinderBottomUp = /* #__PURE__ */ rewriteBottomUp(function (v) {

1344+ return v.onBinder;

1345+});

1346+var rewriteDeclBottomUp = /* #__PURE__ */ rewriteBottomUp(function (v) {

1347+ return v.onDecl;

1348+});

1349+var rewriteExprBottomUp = /* #__PURE__ */ rewriteBottomUp(function (v) {

1350+ return v.onExpr;

1351+});

1352+var rewriteModuleBottomUp = /* #__PURE__ */ rewriteBottomUp(traverseModule1);

1353+var rewriteTypeBottomUp = /* #__PURE__ */ rewriteBottomUp(function (v) {

1354+ return v.onType;

1355+});

1356+export {

1357+ defaultVisitorM,

1358+ rewriteModuleBottomUpM,

1359+ rewriteBinderBottomUpM,

1360+ rewriteExprBottomUpM,

1361+ rewriteDeclBottomUpM,

1362+ rewriteTypeBottomUpM,

1363+ rewriteModuleTopDownM,

1364+ rewriteBinderTopDownM,

1365+ rewriteExprTopDownM,

1366+ rewriteDeclTopDownM,

1367+ rewriteTypeTopDownM,

1368+ defaultVisitorWithContextM,

1369+ rewriteModuleWithContextM,

1370+ rewriteBinderWithContextM,

1371+ rewriteExprWithContextM,

1372+ rewriteDeclWithContextM,

1373+ rewriteTypeWithContextM,

1374+ defaultMonoidalVisitor,

1375+ foldMapModule,

1376+ foldMapBinder,

1377+ foldMapDecl,

1378+ foldMapExpr,

1379+ foldMapType,

1380+ defaultVisitor,

1381+ rewriteModuleBottomUp,

1382+ rewriteBinderBottomUp,

1383+ rewriteExprBottomUp,

1384+ rewriteDeclBottomUp,

1385+ rewriteTypeBottomUp,

1386+ rewriteModuleTopDown,

1387+ rewriteBinderTopDown,

1388+ rewriteExprTopDown,

1389+ rewriteDeclTopDown,

1390+ rewriteTypeTopDown,

1391+ defaultVisitorWithContext,

1392+ rewriteModuleWithContext,

1393+ rewriteBinderWithContext,

1394+ rewriteExprWithContext,

1395+ rewriteDeclWithContext,

1396+ rewriteTypeWithContext,

1397+ traverseModule,

1398+ traverseModuleBody,

1399+ traverseDecl,

1400+ traverseForeign,

1401+ traverseInstance,

1402+ traverseInstanceHead,

1403+ traverseInstanceBinding,

1404+ traverseClassHead,

1405+ traverseOneOrDelimited,

1406+ traverseDataHead,

1407+ traverseDataCtor,

1408+ traverseType,

1409+ traverseRow,

1410+ traverseTypeVarBinding,

1411+ traverseExpr,

1412+ traverseExprAppSpine,

1413+ traverseDelimited,

1414+ traverseDelimitedNonEmpty,

1415+ traverseSeparated,

1416+ traverseWrapped,

1417+ traverseRecordLabeled,

1418+ traverseLabeled,

1419+ traverseRecordAccessor,

1420+ traverseRecordUpdate,

1421+ traverseLambda,

1422+ traverseIfThenElse,

1423+ traverseCaseOf,

1424+ traverseGuarded,

1425+ traverseGuardedExpr,

1426+ traversePatternGuard,

1427+ traverseWhere,

1428+ traverseLetBinding,

1429+ traverseValueBindingFields,

1430+ traverseLetIn,

1431+ traverseDoStatement,

1432+ traverseDoBlock,

1433+ traverseAdoBlock,

1434+ traverseBinder,

1435+ bottomUpTraversal,

1436+ rewriteBottomUpM,

1437+ topDownTraversal,

1438+ rewriteTopDownM,

1439+ topDownTraversalWithContextM,

1440+ rewriteWithContextM,

1441+ topDownMonoidalTraversal,

1442+ monoidalRewrite,

1443+ bottomUpPureTraversal,

1444+ rewriteBottomUp,

1445+ topDownPureTraversal,

1446+ rewriteTopDown,

1447+ topDownTraversalWithContext,

1448+ rewriteWithContext

1449+};

output-compile-fail/PureScript.CST.Types/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST.Types/index.jsnew file+2265

@@ -0,0 +1,2265 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Eq from "../Data.Eq/index.js";

3+import * as Data_Maybe from "../Data.Maybe/index.js";

4+import * as Data_Ord from "../Data.Ord/index.js";

5+var ASCII = /* #__PURE__ */ (function () {

6+ function ASCII() {

7+

8+ };

9+ ASCII.value = new ASCII();

10+ return ASCII;

11+})();

12+var Unicode = /* #__PURE__ */ (function () {

13+ function Unicode() {

14+

15+ };

16+ Unicode.value = new Unicode();

17+ return Unicode;

18+})();

19+var Nominal = /* #__PURE__ */ (function () {

20+ function Nominal() {

21+

22+ };

23+ Nominal.value = new Nominal();

24+ return Nominal;

25+})();

26+var Representational = /* #__PURE__ */ (function () {

27+ function Representational() {

28+

29+ };

30+ Representational.value = new Representational();

31+ return Representational;

32+})();

33+var Phantom = /* #__PURE__ */ (function () {

34+ function Phantom() {

35+

36+ };

37+ Phantom.value = new Phantom();

38+ return Phantom;

39+})();

40+var Proper = function (x) {

41+ return x;

42+};

43+var Operator = function (x) {

44+ return x;

45+};

46+var ModuleName = function (x) {

47+ return x;

48+};

49+var LF = /* #__PURE__ */ (function () {

50+ function LF() {

51+

52+ };

53+ LF.value = new LF();

54+ return LF;

55+})();

56+var CRLF = /* #__PURE__ */ (function () {

57+ function CRLF() {

58+

59+ };

60+ CRLF.value = new CRLF();

61+ return CRLF;

62+})();

63+var Label = function (x) {

64+ return x;

65+};

66+var SmallInt = /* #__PURE__ */ (function () {

67+ function SmallInt(value0) {

68+ this.value0 = value0;

69+ };

70+ SmallInt.create = function (value0) {

71+ return new SmallInt(value0);

72+ };

73+ return SmallInt;

74+})();

75+var BigInt = /* #__PURE__ */ (function () {

76+ function BigInt(value0) {

77+ this.value0 = value0;

78+ };

79+ BigInt.create = function (value0) {

80+ return new BigInt(value0);

81+ };

82+ return BigInt;

83+})();

84+var BigHex = /* #__PURE__ */ (function () {

85+ function BigHex(value0) {

86+ this.value0 = value0;

87+ };

88+ BigHex.create = function (value0) {

89+ return new BigHex(value0);

90+ };

91+ return BigHex;

92+})();

93+var TokLeftParen = /* #__PURE__ */ (function () {

94+ function TokLeftParen() {

95+

96+ };

97+ TokLeftParen.value = new TokLeftParen();

98+ return TokLeftParen;

99+})();

100+var TokRightParen = /* #__PURE__ */ (function () {

101+ function TokRightParen() {

102+

103+ };

104+ TokRightParen.value = new TokRightParen();

105+ return TokRightParen;

106+})();

107+var TokLeftBrace = /* #__PURE__ */ (function () {

108+ function TokLeftBrace() {

109+

110+ };

111+ TokLeftBrace.value = new TokLeftBrace();

112+ return TokLeftBrace;

113+})();

114+var TokRightBrace = /* #__PURE__ */ (function () {

115+ function TokRightBrace() {

116+

117+ };

118+ TokRightBrace.value = new TokRightBrace();

119+ return TokRightBrace;

120+})();

121+var TokLeftSquare = /* #__PURE__ */ (function () {

122+ function TokLeftSquare() {

123+

124+ };

125+ TokLeftSquare.value = new TokLeftSquare();

126+ return TokLeftSquare;

127+})();

128+var TokRightSquare = /* #__PURE__ */ (function () {

129+ function TokRightSquare() {

130+

131+ };

132+ TokRightSquare.value = new TokRightSquare();

133+ return TokRightSquare;

134+})();

135+var TokLeftArrow = /* #__PURE__ */ (function () {

136+ function TokLeftArrow(value0) {

137+ this.value0 = value0;

138+ };

139+ TokLeftArrow.create = function (value0) {

140+ return new TokLeftArrow(value0);

141+ };

142+ return TokLeftArrow;

143+})();

144+var TokRightArrow = /* #__PURE__ */ (function () {

145+ function TokRightArrow(value0) {

146+ this.value0 = value0;

147+ };

148+ TokRightArrow.create = function (value0) {

149+ return new TokRightArrow(value0);

150+ };

151+ return TokRightArrow;

152+})();

153+var TokRightFatArrow = /* #__PURE__ */ (function () {

154+ function TokRightFatArrow(value0) {

155+ this.value0 = value0;

156+ };

157+ TokRightFatArrow.create = function (value0) {

158+ return new TokRightFatArrow(value0);

159+ };

160+ return TokRightFatArrow;

161+})();

162+var TokDoubleColon = /* #__PURE__ */ (function () {

163+ function TokDoubleColon(value0) {

164+ this.value0 = value0;

165+ };

166+ TokDoubleColon.create = function (value0) {

167+ return new TokDoubleColon(value0);

168+ };

169+ return TokDoubleColon;

170+})();

171+var TokForall = /* #__PURE__ */ (function () {

172+ function TokForall(value0) {

173+ this.value0 = value0;

174+ };

175+ TokForall.create = function (value0) {

176+ return new TokForall(value0);

177+ };

178+ return TokForall;

179+})();

180+var TokEquals = /* #__PURE__ */ (function () {

181+ function TokEquals() {

182+

183+ };

184+ TokEquals.value = new TokEquals();

185+ return TokEquals;

186+})();

187+var TokPipe = /* #__PURE__ */ (function () {

188+ function TokPipe() {

189+

190+ };

191+ TokPipe.value = new TokPipe();

192+ return TokPipe;

193+})();

194+var TokTick = /* #__PURE__ */ (function () {

195+ function TokTick() {

196+

197+ };

198+ TokTick.value = new TokTick();

199+ return TokTick;

200+})();

201+var TokDot = /* #__PURE__ */ (function () {

202+ function TokDot() {

203+

204+ };

205+ TokDot.value = new TokDot();

206+ return TokDot;

207+})();

208+var TokComma = /* #__PURE__ */ (function () {

209+ function TokComma() {

210+

211+ };

212+ TokComma.value = new TokComma();

213+ return TokComma;

214+})();

215+var TokUnderscore = /* #__PURE__ */ (function () {

216+ function TokUnderscore() {

217+

218+ };

219+ TokUnderscore.value = new TokUnderscore();

220+ return TokUnderscore;

221+})();

222+var TokBackslash = /* #__PURE__ */ (function () {

223+ function TokBackslash() {

224+

225+ };

226+ TokBackslash.value = new TokBackslash();

227+ return TokBackslash;

228+})();

229+var TokAt = /* #__PURE__ */ (function () {

230+ function TokAt() {

231+

232+ };

233+ TokAt.value = new TokAt();

234+ return TokAt;

235+})();

236+var TokLowerName = /* #__PURE__ */ (function () {

237+ function TokLowerName(value0, value1) {

238+ this.value0 = value0;

239+ this.value1 = value1;

240+ };

241+ TokLowerName.create = function (value0) {

242+ return function (value1) {

243+ return new TokLowerName(value0, value1);

244+ };

245+ };

246+ return TokLowerName;

247+})();

248+var TokUpperName = /* #__PURE__ */ (function () {

249+ function TokUpperName(value0, value1) {

250+ this.value0 = value0;

251+ this.value1 = value1;

252+ };

253+ TokUpperName.create = function (value0) {

254+ return function (value1) {

255+ return new TokUpperName(value0, value1);

256+ };

257+ };

258+ return TokUpperName;

259+})();

260+var TokOperator = /* #__PURE__ */ (function () {

261+ function TokOperator(value0, value1) {

262+ this.value0 = value0;

263+ this.value1 = value1;

264+ };

265+ TokOperator.create = function (value0) {

266+ return function (value1) {

267+ return new TokOperator(value0, value1);

268+ };

269+ };

270+ return TokOperator;

271+})();

272+var TokSymbolName = /* #__PURE__ */ (function () {

273+ function TokSymbolName(value0, value1) {

274+ this.value0 = value0;

275+ this.value1 = value1;

276+ };

277+ TokSymbolName.create = function (value0) {

278+ return function (value1) {

279+ return new TokSymbolName(value0, value1);

280+ };

281+ };

282+ return TokSymbolName;

283+})();

284+var TokSymbolArrow = /* #__PURE__ */ (function () {

285+ function TokSymbolArrow(value0) {

286+ this.value0 = value0;

287+ };

288+ TokSymbolArrow.create = function (value0) {

289+ return new TokSymbolArrow(value0);

290+ };

291+ return TokSymbolArrow;

292+})();

293+var TokHole = /* #__PURE__ */ (function () {

294+ function TokHole(value0) {

295+ this.value0 = value0;

296+ };

297+ TokHole.create = function (value0) {

298+ return new TokHole(value0);

299+ };

300+ return TokHole;

301+})();

302+var TokChar = /* #__PURE__ */ (function () {

303+ function TokChar(value0, value1) {

304+ this.value0 = value0;

305+ this.value1 = value1;

306+ };

307+ TokChar.create = function (value0) {

308+ return function (value1) {

309+ return new TokChar(value0, value1);

310+ };

311+ };

312+ return TokChar;

313+})();

314+var TokString = /* #__PURE__ */ (function () {

315+ function TokString(value0, value1) {

316+ this.value0 = value0;

317+ this.value1 = value1;

318+ };

319+ TokString.create = function (value0) {

320+ return function (value1) {

321+ return new TokString(value0, value1);

322+ };

323+ };

324+ return TokString;

325+})();

326+var TokRawString = /* #__PURE__ */ (function () {

327+ function TokRawString(value0) {

328+ this.value0 = value0;

329+ };

330+ TokRawString.create = function (value0) {

331+ return new TokRawString(value0);

332+ };

333+ return TokRawString;

334+})();

335+var TokInt = /* #__PURE__ */ (function () {

336+ function TokInt(value0, value1) {

337+ this.value0 = value0;

338+ this.value1 = value1;

339+ };

340+ TokInt.create = function (value0) {

341+ return function (value1) {

342+ return new TokInt(value0, value1);

343+ };

344+ };

345+ return TokInt;

346+})();

347+var TokNumber = /* #__PURE__ */ (function () {

348+ function TokNumber(value0, value1) {

349+ this.value0 = value0;

350+ this.value1 = value1;

351+ };

352+ TokNumber.create = function (value0) {

353+ return function (value1) {

354+ return new TokNumber(value0, value1);

355+ };

356+ };

357+ return TokNumber;

358+})();

359+var TokLayoutStart = /* #__PURE__ */ (function () {

360+ function TokLayoutStart(value0) {

361+ this.value0 = value0;

362+ };

363+ TokLayoutStart.create = function (value0) {

364+ return new TokLayoutStart(value0);

365+ };

366+ return TokLayoutStart;

367+})();

368+var TokLayoutSep = /* #__PURE__ */ (function () {

369+ function TokLayoutSep(value0) {

370+ this.value0 = value0;

371+ };

372+ TokLayoutSep.create = function (value0) {

373+ return new TokLayoutSep(value0);

374+ };

375+ return TokLayoutSep;

376+})();

377+var TokLayoutEnd = /* #__PURE__ */ (function () {

378+ function TokLayoutEnd(value0) {

379+ this.value0 = value0;

380+ };

381+ TokLayoutEnd.create = function (value0) {

382+ return new TokLayoutEnd(value0);

383+ };

384+ return TokLayoutEnd;

385+})();

386+var Ident = function (x) {

387+ return x;

388+};

389+var Infix = /* #__PURE__ */ (function () {

390+ function Infix() {

391+

392+ };

393+ Infix.value = new Infix();

394+ return Infix;

395+})();

396+var Infixl = /* #__PURE__ */ (function () {

397+ function Infixl() {

398+

399+ };

400+ Infixl.value = new Infixl();

401+ return Infixl;

402+})();

403+var Infixr = /* #__PURE__ */ (function () {

404+ function Infixr() {

405+

406+ };

407+ Infixr.value = new Infixr();

408+ return Infixr;

409+})();

410+var Comment = /* #__PURE__ */ (function () {

411+ function Comment(value0) {

412+ this.value0 = value0;

413+ };

414+ Comment.create = function (value0) {

415+ return new Comment(value0);

416+ };

417+ return Comment;

418+})();

419+var Space = /* #__PURE__ */ (function () {

420+ function Space(value0) {

421+ this.value0 = value0;

422+ };

423+ Space.create = function (value0) {

424+ return new Space(value0);

425+ };

426+ return Space;

427+})();

428+var Line = /* #__PURE__ */ (function () {

429+ function Line(value0, value1) {

430+ this.value0 = value0;

431+ this.value1 = value1;

432+ };

433+ Line.create = function (value0) {

434+ return function (value1) {

435+ return new Line(value0, value1);

436+ };

437+ };

438+ return Line;

439+})();

440+var Labeled = function (x) {

441+ return x;

442+};

443+var Name = function (x) {

444+ return x;

445+};

446+var Prefixed = function (x) {

447+ return x;

448+};

449+var QualifiedName = function (x) {

450+ return x;

451+};

452+var FixityValue = /* #__PURE__ */ (function () {

453+ function FixityValue(value0, value1, value2) {

454+ this.value0 = value0;

455+ this.value1 = value1;

456+ this.value2 = value2;

457+ };

458+ FixityValue.create = function (value0) {

459+ return function (value1) {

460+ return function (value2) {

461+ return new FixityValue(value0, value1, value2);

462+ };

463+ };

464+ };

465+ return FixityValue;

466+})();

467+var FixityType = /* #__PURE__ */ (function () {

468+ function FixityType(value0, value1, value2, value3) {

469+ this.value0 = value0;

470+ this.value1 = value1;

471+ this.value2 = value2;

472+ this.value3 = value3;

473+ };

474+ FixityType.create = function (value0) {

475+ return function (value1) {

476+ return function (value2) {

477+ return function (value3) {

478+ return new FixityType(value0, value1, value2, value3);

479+ };

480+ };

481+ };

482+ };

483+ return FixityType;

484+})();

485+var RecordPun = /* #__PURE__ */ (function () {

486+ function RecordPun(value0) {

487+ this.value0 = value0;

488+ };

489+ RecordPun.create = function (value0) {

490+ return new RecordPun(value0);

491+ };

492+ return RecordPun;

493+})();

494+var RecordField = /* #__PURE__ */ (function () {

495+ function RecordField(value0, value1, value2) {

496+ this.value0 = value0;

497+ this.value1 = value1;

498+ this.value2 = value2;

499+ };

500+ RecordField.create = function (value0) {

501+ return function (value1) {

502+ return function (value2) {

503+ return new RecordField(value0, value1, value2);

504+ };

505+ };

506+ };

507+ return RecordField;

508+})();

509+var Separated = function (x) {

510+ return x;

511+};

512+var Wrapped = function (x) {

513+ return x;

514+};

515+var DataAll = /* #__PURE__ */ (function () {

516+ function DataAll(value0) {

517+ this.value0 = value0;

518+ };

519+ DataAll.create = function (value0) {

520+ return new DataAll(value0);

521+ };

522+ return DataAll;

523+})();

524+var DataEnumerated = /* #__PURE__ */ (function () {

525+ function DataEnumerated(value0) {

526+ this.value0 = value0;

527+ };

528+ DataEnumerated.create = function (value0) {

529+ return new DataEnumerated(value0);

530+ };

531+ return DataEnumerated;

532+})();

533+var ExportValue = /* #__PURE__ */ (function () {

534+ function ExportValue(value0) {

535+ this.value0 = value0;

536+ };

537+ ExportValue.create = function (value0) {

538+ return new ExportValue(value0);

539+ };

540+ return ExportValue;

541+})();

542+var ExportOp = /* #__PURE__ */ (function () {

543+ function ExportOp(value0) {

544+ this.value0 = value0;

545+ };

546+ ExportOp.create = function (value0) {

547+ return new ExportOp(value0);

548+ };

549+ return ExportOp;

550+})();

551+var ExportType = /* #__PURE__ */ (function () {

552+ function ExportType(value0, value1) {

553+ this.value0 = value0;

554+ this.value1 = value1;

555+ };

556+ ExportType.create = function (value0) {

557+ return function (value1) {

558+ return new ExportType(value0, value1);

559+ };

560+ };

561+ return ExportType;

562+})();

563+var ExportTypeOp = /* #__PURE__ */ (function () {

564+ function ExportTypeOp(value0, value1) {

565+ this.value0 = value0;

566+ this.value1 = value1;

567+ };

568+ ExportTypeOp.create = function (value0) {

569+ return function (value1) {

570+ return new ExportTypeOp(value0, value1);

571+ };

572+ };

573+ return ExportTypeOp;

574+})();

575+var ExportClass = /* #__PURE__ */ (function () {

576+ function ExportClass(value0, value1) {

577+ this.value0 = value0;

578+ this.value1 = value1;

579+ };

580+ ExportClass.create = function (value0) {

581+ return function (value1) {

582+ return new ExportClass(value0, value1);

583+ };

584+ };

585+ return ExportClass;

586+})();

587+var ExportModule = /* #__PURE__ */ (function () {

588+ function ExportModule(value0, value1) {

589+ this.value0 = value0;

590+ this.value1 = value1;

591+ };

592+ ExportModule.create = function (value0) {

593+ return function (value1) {

594+ return new ExportModule(value0, value1);

595+ };

596+ };

597+ return ExportModule;

598+})();

599+var ExportError = /* #__PURE__ */ (function () {

600+ function ExportError(value0) {

601+ this.value0 = value0;

602+ };

603+ ExportError.create = function (value0) {

604+ return new ExportError(value0);

605+ };

606+ return ExportError;

607+})();

608+var ImportValue = /* #__PURE__ */ (function () {

609+ function ImportValue(value0) {

610+ this.value0 = value0;

611+ };

612+ ImportValue.create = function (value0) {

613+ return new ImportValue(value0);

614+ };

615+ return ImportValue;

616+})();

617+var ImportOp = /* #__PURE__ */ (function () {

618+ function ImportOp(value0) {

619+ this.value0 = value0;

620+ };

621+ ImportOp.create = function (value0) {

622+ return new ImportOp(value0);

623+ };

624+ return ImportOp;

625+})();

626+var ImportType = /* #__PURE__ */ (function () {

627+ function ImportType(value0, value1) {

628+ this.value0 = value0;

629+ this.value1 = value1;

630+ };

631+ ImportType.create = function (value0) {

632+ return function (value1) {

633+ return new ImportType(value0, value1);

634+ };

635+ };

636+ return ImportType;

637+})();

638+var ImportTypeOp = /* #__PURE__ */ (function () {

639+ function ImportTypeOp(value0, value1) {

640+ this.value0 = value0;

641+ this.value1 = value1;

642+ };

643+ ImportTypeOp.create = function (value0) {

644+ return function (value1) {

645+ return new ImportTypeOp(value0, value1);

646+ };

647+ };

648+ return ImportTypeOp;

649+})();

650+var ImportClass = /* #__PURE__ */ (function () {

651+ function ImportClass(value0, value1) {

652+ this.value0 = value0;

653+ this.value1 = value1;

654+ };

655+ ImportClass.create = function (value0) {

656+ return function (value1) {

657+ return new ImportClass(value0, value1);

658+ };

659+ };

660+ return ImportClass;

661+})();

662+var ImportError = /* #__PURE__ */ (function () {

663+ function ImportError(value0) {

664+ this.value0 = value0;

665+ };

666+ ImportError.create = function (value0) {

667+ return new ImportError(value0);

668+ };

669+ return ImportError;

670+})();

671+var ImportDecl = function (x) {

672+ return x;

673+};

674+var ModuleHeader = function (x) {

675+ return x;

676+};

677+var One = /* #__PURE__ */ (function () {

678+ function One(value0) {

679+ this.value0 = value0;

680+ };

681+ One.create = function (value0) {

682+ return new One(value0);

683+ };

684+ return One;

685+})();

686+var Many = /* #__PURE__ */ (function () {

687+ function Many(value0) {

688+ this.value0 = value0;

689+ };

690+ Many.create = function (value0) {

691+ return new Many(value0);

692+ };

693+ return Many;

694+})();

695+var TypeVarKinded = /* #__PURE__ */ (function () {

696+ function TypeVarKinded(value0) {

697+ this.value0 = value0;

698+ };

699+ TypeVarKinded.create = function (value0) {

700+ return new TypeVarKinded(value0);

701+ };

702+ return TypeVarKinded;

703+})();

704+var TypeVarName = /* #__PURE__ */ (function () {

705+ function TypeVarName(value0) {

706+ this.value0 = value0;

707+ };

708+ TypeVarName.create = function (value0) {

709+ return new TypeVarName(value0);

710+ };

711+ return TypeVarName;

712+})();

713+var TypeVar = /* #__PURE__ */ (function () {

714+ function TypeVar(value0) {

715+ this.value0 = value0;

716+ };

717+ TypeVar.create = function (value0) {

718+ return new TypeVar(value0);

719+ };

720+ return TypeVar;

721+})();

722+var TypeConstructor = /* #__PURE__ */ (function () {

723+ function TypeConstructor(value0) {

724+ this.value0 = value0;

725+ };

726+ TypeConstructor.create = function (value0) {

727+ return new TypeConstructor(value0);

728+ };

729+ return TypeConstructor;

730+})();

731+var TypeWildcard = /* #__PURE__ */ (function () {

732+ function TypeWildcard(value0) {

733+ this.value0 = value0;

734+ };

735+ TypeWildcard.create = function (value0) {

736+ return new TypeWildcard(value0);

737+ };

738+ return TypeWildcard;

739+})();

740+var TypeHole = /* #__PURE__ */ (function () {

741+ function TypeHole(value0) {

742+ this.value0 = value0;

743+ };

744+ TypeHole.create = function (value0) {

745+ return new TypeHole(value0);

746+ };

747+ return TypeHole;

748+})();

749+var TypeString = /* #__PURE__ */ (function () {

750+ function TypeString(value0, value1) {

751+ this.value0 = value0;

752+ this.value1 = value1;

753+ };

754+ TypeString.create = function (value0) {

755+ return function (value1) {

756+ return new TypeString(value0, value1);

757+ };

758+ };

759+ return TypeString;

760+})();

761+var TypeInt = /* #__PURE__ */ (function () {

762+ function TypeInt(value0, value1, value2) {

763+ this.value0 = value0;

764+ this.value1 = value1;

765+ this.value2 = value2;

766+ };

767+ TypeInt.create = function (value0) {

768+ return function (value1) {

769+ return function (value2) {

770+ return new TypeInt(value0, value1, value2);

771+ };

772+ };

773+ };

774+ return TypeInt;

775+})();

776+var TypeRow = /* #__PURE__ */ (function () {

777+ function TypeRow(value0) {

778+ this.value0 = value0;

779+ };

780+ TypeRow.create = function (value0) {

781+ return new TypeRow(value0);

782+ };

783+ return TypeRow;

784+})();

785+var TypeRecord = /* #__PURE__ */ (function () {

786+ function TypeRecord(value0) {

787+ this.value0 = value0;

788+ };

789+ TypeRecord.create = function (value0) {

790+ return new TypeRecord(value0);

791+ };

792+ return TypeRecord;

793+})();

794+var TypeForall = /* #__PURE__ */ (function () {

795+ function TypeForall(value0, value1, value2, value3) {

796+ this.value0 = value0;

797+ this.value1 = value1;

798+ this.value2 = value2;

799+ this.value3 = value3;

800+ };

801+ TypeForall.create = function (value0) {

802+ return function (value1) {

803+ return function (value2) {

804+ return function (value3) {

805+ return new TypeForall(value0, value1, value2, value3);

806+ };

807+ };

808+ };

809+ };

810+ return TypeForall;

811+})();

812+var TypeKinded = /* #__PURE__ */ (function () {

813+ function TypeKinded(value0, value1, value2) {

814+ this.value0 = value0;

815+ this.value1 = value1;

816+ this.value2 = value2;

817+ };

818+ TypeKinded.create = function (value0) {

819+ return function (value1) {

820+ return function (value2) {

821+ return new TypeKinded(value0, value1, value2);

822+ };

823+ };

824+ };

825+ return TypeKinded;

826+})();

827+var TypeApp = /* #__PURE__ */ (function () {

828+ function TypeApp(value0, value1) {

829+ this.value0 = value0;

830+ this.value1 = value1;

831+ };

832+ TypeApp.create = function (value0) {

833+ return function (value1) {

834+ return new TypeApp(value0, value1);

835+ };

836+ };

837+ return TypeApp;

838+})();

839+var TypeOp = /* #__PURE__ */ (function () {

840+ function TypeOp(value0, value1) {

841+ this.value0 = value0;

842+ this.value1 = value1;

843+ };

844+ TypeOp.create = function (value0) {

845+ return function (value1) {

846+ return new TypeOp(value0, value1);

847+ };

848+ };

849+ return TypeOp;

850+})();

851+var TypeOpName = /* #__PURE__ */ (function () {

852+ function TypeOpName(value0) {

853+ this.value0 = value0;

854+ };

855+ TypeOpName.create = function (value0) {

856+ return new TypeOpName(value0);

857+ };

858+ return TypeOpName;

859+})();

860+var TypeArrow = /* #__PURE__ */ (function () {

861+ function TypeArrow(value0, value1, value2) {

862+ this.value0 = value0;

863+ this.value1 = value1;

864+ this.value2 = value2;

865+ };

866+ TypeArrow.create = function (value0) {

867+ return function (value1) {

868+ return function (value2) {

869+ return new TypeArrow(value0, value1, value2);

870+ };

871+ };

872+ };

873+ return TypeArrow;

874+})();

875+var TypeArrowName = /* #__PURE__ */ (function () {

876+ function TypeArrowName(value0) {

877+ this.value0 = value0;

878+ };

879+ TypeArrowName.create = function (value0) {

880+ return new TypeArrowName(value0);

881+ };

882+ return TypeArrowName;

883+})();

884+var TypeConstrained = /* #__PURE__ */ (function () {

885+ function TypeConstrained(value0, value1, value2) {

886+ this.value0 = value0;

887+ this.value1 = value1;

888+ this.value2 = value2;

889+ };

890+ TypeConstrained.create = function (value0) {

891+ return function (value1) {

892+ return function (value2) {

893+ return new TypeConstrained(value0, value1, value2);

894+ };

895+ };

896+ };

897+ return TypeConstrained;

898+})();

899+var TypeParens = /* #__PURE__ */ (function () {

900+ function TypeParens(value0) {

901+ this.value0 = value0;

902+ };

903+ TypeParens.create = function (value0) {

904+ return new TypeParens(value0);

905+ };

906+ return TypeParens;

907+})();

908+var $$TypeError = /* #__PURE__ */ (function () {

909+ function $$TypeError(value0) {

910+ this.value0 = value0;

911+ };

912+ $$TypeError.create = function (value0) {

913+ return new $$TypeError(value0);

914+ };

915+ return $$TypeError;

916+})();

917+var Row = function (x) {

918+ return x;

919+};

920+var DataCtor = function (x) {

921+ return x;

922+};

923+var ForeignValue = /* #__PURE__ */ (function () {

924+ function ForeignValue(value0) {

925+ this.value0 = value0;

926+ };

927+ ForeignValue.create = function (value0) {

928+ return new ForeignValue(value0);

929+ };

930+ return ForeignValue;

931+})();

932+var ForeignData = /* #__PURE__ */ (function () {

933+ function ForeignData(value0, value1) {

934+ this.value0 = value0;

935+ this.value1 = value1;

936+ };

937+ ForeignData.create = function (value0) {

938+ return function (value1) {

939+ return new ForeignData(value0, value1);

940+ };

941+ };

942+ return ForeignData;

943+})();

944+var ForeignKind = /* #__PURE__ */ (function () {

945+ function ForeignKind(value0, value1) {

946+ this.value0 = value0;

947+ this.value1 = value1;

948+ };

949+ ForeignKind.create = function (value0) {

950+ return function (value1) {

951+ return new ForeignKind(value0, value1);

952+ };

953+ };

954+ return ForeignKind;

955+})();

956+var FundepDetermined = /* #__PURE__ */ (function () {

957+ function FundepDetermined(value0, value1) {

958+ this.value0 = value0;

959+ this.value1 = value1;

960+ };

961+ FundepDetermined.create = function (value0) {

962+ return function (value1) {

963+ return new FundepDetermined(value0, value1);

964+ };

965+ };

966+ return FundepDetermined;

967+})();

968+var FundepDetermines = /* #__PURE__ */ (function () {

969+ function FundepDetermines(value0, value1, value2) {

970+ this.value0 = value0;

971+ this.value1 = value1;

972+ this.value2 = value2;

973+ };

974+ FundepDetermines.create = function (value0) {

975+ return function (value1) {

976+ return function (value2) {

977+ return new FundepDetermines(value0, value1, value2);

978+ };

979+ };

980+ };

981+ return FundepDetermines;

982+})();

983+var BinderWildcard = /* #__PURE__ */ (function () {

984+ function BinderWildcard(value0) {

985+ this.value0 = value0;

986+ };

987+ BinderWildcard.create = function (value0) {

988+ return new BinderWildcard(value0);

989+ };

990+ return BinderWildcard;

991+})();

992+var BinderVar = /* #__PURE__ */ (function () {

993+ function BinderVar(value0) {

994+ this.value0 = value0;

995+ };

996+ BinderVar.create = function (value0) {

997+ return new BinderVar(value0);

998+ };

999+ return BinderVar;

1000+})();

1001+var BinderNamed = /* #__PURE__ */ (function () {

1002+ function BinderNamed(value0, value1, value2) {

1003+ this.value0 = value0;

1004+ this.value1 = value1;

1005+ this.value2 = value2;

1006+ };

1007+ BinderNamed.create = function (value0) {

1008+ return function (value1) {

1009+ return function (value2) {

1010+ return new BinderNamed(value0, value1, value2);

1011+ };

1012+ };

1013+ };

1014+ return BinderNamed;

1015+})();

1016+var BinderConstructor = /* #__PURE__ */ (function () {

1017+ function BinderConstructor(value0, value1) {

1018+ this.value0 = value0;

1019+ this.value1 = value1;

1020+ };

1021+ BinderConstructor.create = function (value0) {

1022+ return function (value1) {

1023+ return new BinderConstructor(value0, value1);

1024+ };

1025+ };

1026+ return BinderConstructor;

1027+})();

1028+var BinderBoolean = /* #__PURE__ */ (function () {

1029+ function BinderBoolean(value0, value1) {

1030+ this.value0 = value0;

1031+ this.value1 = value1;

1032+ };

1033+ BinderBoolean.create = function (value0) {

1034+ return function (value1) {

1035+ return new BinderBoolean(value0, value1);

1036+ };

1037+ };

1038+ return BinderBoolean;

1039+})();

1040+var BinderChar = /* #__PURE__ */ (function () {

1041+ function BinderChar(value0, value1) {

1042+ this.value0 = value0;

1043+ this.value1 = value1;

1044+ };

1045+ BinderChar.create = function (value0) {

1046+ return function (value1) {

1047+ return new BinderChar(value0, value1);

1048+ };

1049+ };

1050+ return BinderChar;

1051+})();

1052+var BinderString = /* #__PURE__ */ (function () {

1053+ function BinderString(value0, value1) {

1054+ this.value0 = value0;

1055+ this.value1 = value1;

1056+ };

1057+ BinderString.create = function (value0) {

1058+ return function (value1) {

1059+ return new BinderString(value0, value1);

1060+ };

1061+ };

1062+ return BinderString;

1063+})();

1064+var BinderInt = /* #__PURE__ */ (function () {

1065+ function BinderInt(value0, value1, value2) {

1066+ this.value0 = value0;

1067+ this.value1 = value1;

1068+ this.value2 = value2;

1069+ };

1070+ BinderInt.create = function (value0) {

1071+ return function (value1) {

1072+ return function (value2) {

1073+ return new BinderInt(value0, value1, value2);

1074+ };

1075+ };

1076+ };

1077+ return BinderInt;

1078+})();

1079+var BinderNumber = /* #__PURE__ */ (function () {

1080+ function BinderNumber(value0, value1, value2) {

1081+ this.value0 = value0;

1082+ this.value1 = value1;

1083+ this.value2 = value2;

1084+ };

1085+ BinderNumber.create = function (value0) {

1086+ return function (value1) {

1087+ return function (value2) {

1088+ return new BinderNumber(value0, value1, value2);

1089+ };

1090+ };

1091+ };

1092+ return BinderNumber;

1093+})();

1094+var BinderArray = /* #__PURE__ */ (function () {

1095+ function BinderArray(value0) {

1096+ this.value0 = value0;

1097+ };

1098+ BinderArray.create = function (value0) {

1099+ return new BinderArray(value0);

1100+ };

1101+ return BinderArray;

1102+})();

1103+var BinderRecord = /* #__PURE__ */ (function () {

1104+ function BinderRecord(value0) {

1105+ this.value0 = value0;

1106+ };

1107+ BinderRecord.create = function (value0) {

1108+ return new BinderRecord(value0);

1109+ };

1110+ return BinderRecord;

1111+})();

1112+var BinderParens = /* #__PURE__ */ (function () {

1113+ function BinderParens(value0) {

1114+ this.value0 = value0;

1115+ };

1116+ BinderParens.create = function (value0) {

1117+ return new BinderParens(value0);

1118+ };

1119+ return BinderParens;

1120+})();

1121+var BinderTyped = /* #__PURE__ */ (function () {

1122+ function BinderTyped(value0, value1, value2) {

1123+ this.value0 = value0;

1124+ this.value1 = value1;

1125+ this.value2 = value2;

1126+ };

1127+ BinderTyped.create = function (value0) {

1128+ return function (value1) {

1129+ return function (value2) {

1130+ return new BinderTyped(value0, value1, value2);

1131+ };

1132+ };

1133+ };

1134+ return BinderTyped;

1135+})();

1136+var BinderOp = /* #__PURE__ */ (function () {

1137+ function BinderOp(value0, value1) {

1138+ this.value0 = value0;

1139+ this.value1 = value1;

1140+ };

1141+ BinderOp.create = function (value0) {

1142+ return function (value1) {

1143+ return new BinderOp(value0, value1);

1144+ };

1145+ };

1146+ return BinderOp;

1147+})();

1148+var BinderError = /* #__PURE__ */ (function () {

1149+ function BinderError(value0) {

1150+ this.value0 = value0;

1151+ };

1152+ BinderError.create = function (value0) {

1153+ return new BinderError(value0);

1154+ };

1155+ return BinderError;

1156+})();

1157+var AppType = /* #__PURE__ */ (function () {

1158+ function AppType(value0, value1) {

1159+ this.value0 = value0;

1160+ this.value1 = value1;

1161+ };

1162+ AppType.create = function (value0) {

1163+ return function (value1) {

1164+ return new AppType(value0, value1);

1165+ };

1166+ };

1167+ return AppType;

1168+})();

1169+var AppTerm = /* #__PURE__ */ (function () {

1170+ function AppTerm(value0) {

1171+ this.value0 = value0;

1172+ };

1173+ AppTerm.create = function (value0) {

1174+ return new AppTerm(value0);

1175+ };

1176+ return AppTerm;

1177+})();

1178+var DoLet = /* #__PURE__ */ (function () {

1179+ function DoLet(value0, value1) {

1180+ this.value0 = value0;

1181+ this.value1 = value1;

1182+ };

1183+ DoLet.create = function (value0) {

1184+ return function (value1) {

1185+ return new DoLet(value0, value1);

1186+ };

1187+ };

1188+ return DoLet;

1189+})();

1190+var DoDiscard = /* #__PURE__ */ (function () {

1191+ function DoDiscard(value0) {

1192+ this.value0 = value0;

1193+ };

1194+ DoDiscard.create = function (value0) {

1195+ return new DoDiscard(value0);

1196+ };

1197+ return DoDiscard;

1198+})();

1199+var DoBind = /* #__PURE__ */ (function () {

1200+ function DoBind(value0, value1, value2) {

1201+ this.value0 = value0;

1202+ this.value1 = value1;

1203+ this.value2 = value2;

1204+ };

1205+ DoBind.create = function (value0) {

1206+ return function (value1) {

1207+ return function (value2) {

1208+ return new DoBind(value0, value1, value2);

1209+ };

1210+ };

1211+ };

1212+ return DoBind;

1213+})();

1214+var DoError = /* #__PURE__ */ (function () {

1215+ function DoError(value0) {

1216+ this.value0 = value0;

1217+ };

1218+ DoError.create = function (value0) {

1219+ return new DoError(value0);

1220+ };

1221+ return DoError;

1222+})();

1223+var LetBindingSignature = /* #__PURE__ */ (function () {

1224+ function LetBindingSignature(value0) {

1225+ this.value0 = value0;

1226+ };

1227+ LetBindingSignature.create = function (value0) {

1228+ return new LetBindingSignature(value0);

1229+ };

1230+ return LetBindingSignature;

1231+})();

1232+var LetBindingName = /* #__PURE__ */ (function () {

1233+ function LetBindingName(value0) {

1234+ this.value0 = value0;

1235+ };

1236+ LetBindingName.create = function (value0) {

1237+ return new LetBindingName(value0);

1238+ };

1239+ return LetBindingName;

1240+})();

1241+var LetBindingPattern = /* #__PURE__ */ (function () {

1242+ function LetBindingPattern(value0, value1, value2) {

1243+ this.value0 = value0;

1244+ this.value1 = value1;

1245+ this.value2 = value2;

1246+ };

1247+ LetBindingPattern.create = function (value0) {

1248+ return function (value1) {

1249+ return function (value2) {

1250+ return new LetBindingPattern(value0, value1, value2);

1251+ };

1252+ };

1253+ };

1254+ return LetBindingPattern;

1255+})();

1256+var LetBindingError = /* #__PURE__ */ (function () {

1257+ function LetBindingError(value0) {

1258+ this.value0 = value0;

1259+ };

1260+ LetBindingError.create = function (value0) {

1261+ return new LetBindingError(value0);

1262+ };

1263+ return LetBindingError;

1264+})();

1265+var Unconditional = /* #__PURE__ */ (function () {

1266+ function Unconditional(value0, value1) {

1267+ this.value0 = value0;

1268+ this.value1 = value1;

1269+ };

1270+ Unconditional.create = function (value0) {

1271+ return function (value1) {

1272+ return new Unconditional(value0, value1);

1273+ };

1274+ };

1275+ return Unconditional;

1276+})();

1277+var Guarded = /* #__PURE__ */ (function () {

1278+ function Guarded(value0) {

1279+ this.value0 = value0;

1280+ };

1281+ Guarded.create = function (value0) {

1282+ return new Guarded(value0);

1283+ };

1284+ return Guarded;

1285+})();

1286+var Where = function (x) {

1287+ return x;

1288+};

1289+var ExprHole = /* #__PURE__ */ (function () {

1290+ function ExprHole(value0) {

1291+ this.value0 = value0;

1292+ };

1293+ ExprHole.create = function (value0) {

1294+ return new ExprHole(value0);

1295+ };

1296+ return ExprHole;

1297+})();

1298+var ExprSection = /* #__PURE__ */ (function () {

1299+ function ExprSection(value0) {

1300+ this.value0 = value0;

1301+ };

1302+ ExprSection.create = function (value0) {

1303+ return new ExprSection(value0);

1304+ };

1305+ return ExprSection;

1306+})();

1307+var ExprIdent = /* #__PURE__ */ (function () {

1308+ function ExprIdent(value0) {

1309+ this.value0 = value0;

1310+ };

1311+ ExprIdent.create = function (value0) {

1312+ return new ExprIdent(value0);

1313+ };

1314+ return ExprIdent;

1315+})();

1316+var ExprConstructor = /* #__PURE__ */ (function () {

1317+ function ExprConstructor(value0) {

1318+ this.value0 = value0;

1319+ };

1320+ ExprConstructor.create = function (value0) {

1321+ return new ExprConstructor(value0);

1322+ };

1323+ return ExprConstructor;

1324+})();

1325+var ExprBoolean = /* #__PURE__ */ (function () {

1326+ function ExprBoolean(value0, value1) {

1327+ this.value0 = value0;

1328+ this.value1 = value1;

1329+ };

1330+ ExprBoolean.create = function (value0) {

1331+ return function (value1) {

1332+ return new ExprBoolean(value0, value1);

1333+ };

1334+ };

1335+ return ExprBoolean;

1336+})();

1337+var ExprChar = /* #__PURE__ */ (function () {

1338+ function ExprChar(value0, value1) {

1339+ this.value0 = value0;

1340+ this.value1 = value1;

1341+ };

1342+ ExprChar.create = function (value0) {

1343+ return function (value1) {

1344+ return new ExprChar(value0, value1);

1345+ };

1346+ };

1347+ return ExprChar;

1348+})();

1349+var ExprString = /* #__PURE__ */ (function () {

1350+ function ExprString(value0, value1) {

1351+ this.value0 = value0;

1352+ this.value1 = value1;

1353+ };

1354+ ExprString.create = function (value0) {

1355+ return function (value1) {

1356+ return new ExprString(value0, value1);

1357+ };

1358+ };

1359+ return ExprString;

1360+})();

1361+var ExprInt = /* #__PURE__ */ (function () {

1362+ function ExprInt(value0, value1) {

1363+ this.value0 = value0;

1364+ this.value1 = value1;

1365+ };

1366+ ExprInt.create = function (value0) {

1367+ return function (value1) {

1368+ return new ExprInt(value0, value1);

1369+ };

1370+ };

1371+ return ExprInt;

1372+})();

1373+var ExprNumber = /* #__PURE__ */ (function () {

1374+ function ExprNumber(value0, value1) {

1375+ this.value0 = value0;

1376+ this.value1 = value1;

1377+ };

1378+ ExprNumber.create = function (value0) {

1379+ return function (value1) {

1380+ return new ExprNumber(value0, value1);

1381+ };

1382+ };

1383+ return ExprNumber;

1384+})();

1385+var ExprArray = /* #__PURE__ */ (function () {

1386+ function ExprArray(value0) {

1387+ this.value0 = value0;

1388+ };

1389+ ExprArray.create = function (value0) {

1390+ return new ExprArray(value0);

1391+ };

1392+ return ExprArray;

1393+})();

1394+var ExprRecord = /* #__PURE__ */ (function () {

1395+ function ExprRecord(value0) {

1396+ this.value0 = value0;

1397+ };

1398+ ExprRecord.create = function (value0) {

1399+ return new ExprRecord(value0);

1400+ };

1401+ return ExprRecord;

1402+})();

1403+var ExprParens = /* #__PURE__ */ (function () {

1404+ function ExprParens(value0) {

1405+ this.value0 = value0;

1406+ };

1407+ ExprParens.create = function (value0) {

1408+ return new ExprParens(value0);

1409+ };

1410+ return ExprParens;

1411+})();

1412+var ExprTyped = /* #__PURE__ */ (function () {

1413+ function ExprTyped(value0, value1, value2) {

1414+ this.value0 = value0;

1415+ this.value1 = value1;

1416+ this.value2 = value2;

1417+ };

1418+ ExprTyped.create = function (value0) {

1419+ return function (value1) {

1420+ return function (value2) {

1421+ return new ExprTyped(value0, value1, value2);

1422+ };

1423+ };

1424+ };

1425+ return ExprTyped;

1426+})();

1427+var ExprInfix = /* #__PURE__ */ (function () {

1428+ function ExprInfix(value0, value1) {

1429+ this.value0 = value0;

1430+ this.value1 = value1;

1431+ };

1432+ ExprInfix.create = function (value0) {

1433+ return function (value1) {

1434+ return new ExprInfix(value0, value1);

1435+ };

1436+ };

1437+ return ExprInfix;

1438+})();

1439+var ExprOp = /* #__PURE__ */ (function () {

1440+ function ExprOp(value0, value1) {

1441+ this.value0 = value0;

1442+ this.value1 = value1;

1443+ };

1444+ ExprOp.create = function (value0) {

1445+ return function (value1) {

1446+ return new ExprOp(value0, value1);

1447+ };

1448+ };

1449+ return ExprOp;

1450+})();

1451+var ExprOpName = /* #__PURE__ */ (function () {

1452+ function ExprOpName(value0) {

1453+ this.value0 = value0;

1454+ };

1455+ ExprOpName.create = function (value0) {

1456+ return new ExprOpName(value0);

1457+ };

1458+ return ExprOpName;

1459+})();

1460+var ExprNegate = /* #__PURE__ */ (function () {

1461+ function ExprNegate(value0, value1) {

1462+ this.value0 = value0;

1463+ this.value1 = value1;

1464+ };

1465+ ExprNegate.create = function (value0) {

1466+ return function (value1) {

1467+ return new ExprNegate(value0, value1);

1468+ };

1469+ };

1470+ return ExprNegate;

1471+})();

1472+var ExprRecordAccessor = /* #__PURE__ */ (function () {

1473+ function ExprRecordAccessor(value0) {

1474+ this.value0 = value0;

1475+ };

1476+ ExprRecordAccessor.create = function (value0) {

1477+ return new ExprRecordAccessor(value0);

1478+ };

1479+ return ExprRecordAccessor;

1480+})();

1481+var ExprRecordUpdate = /* #__PURE__ */ (function () {

1482+ function ExprRecordUpdate(value0, value1) {

1483+ this.value0 = value0;

1484+ this.value1 = value1;

1485+ };

1486+ ExprRecordUpdate.create = function (value0) {

1487+ return function (value1) {

1488+ return new ExprRecordUpdate(value0, value1);

1489+ };

1490+ };

1491+ return ExprRecordUpdate;

1492+})();

1493+var ExprApp = /* #__PURE__ */ (function () {

1494+ function ExprApp(value0, value1) {

1495+ this.value0 = value0;

1496+ this.value1 = value1;

1497+ };

1498+ ExprApp.create = function (value0) {

1499+ return function (value1) {

1500+ return new ExprApp(value0, value1);

1501+ };

1502+ };

1503+ return ExprApp;

1504+})();

1505+var ExprLambda = /* #__PURE__ */ (function () {

1506+ function ExprLambda(value0) {

1507+ this.value0 = value0;

1508+ };

1509+ ExprLambda.create = function (value0) {

1510+ return new ExprLambda(value0);

1511+ };

1512+ return ExprLambda;

1513+})();

1514+var ExprIf = /* #__PURE__ */ (function () {

1515+ function ExprIf(value0) {

1516+ this.value0 = value0;

1517+ };

1518+ ExprIf.create = function (value0) {

1519+ return new ExprIf(value0);

1520+ };

1521+ return ExprIf;

1522+})();

1523+var ExprCase = /* #__PURE__ */ (function () {

1524+ function ExprCase(value0) {

1525+ this.value0 = value0;

1526+ };

1527+ ExprCase.create = function (value0) {

1528+ return new ExprCase(value0);

1529+ };

1530+ return ExprCase;

1531+})();

1532+var ExprLet = /* #__PURE__ */ (function () {

1533+ function ExprLet(value0) {

1534+ this.value0 = value0;

1535+ };

1536+ ExprLet.create = function (value0) {

1537+ return new ExprLet(value0);

1538+ };

1539+ return ExprLet;

1540+})();

1541+var ExprDo = /* #__PURE__ */ (function () {

1542+ function ExprDo(value0) {

1543+ this.value0 = value0;

1544+ };

1545+ ExprDo.create = function (value0) {

1546+ return new ExprDo(value0);

1547+ };

1548+ return ExprDo;

1549+})();

1550+var ExprAdo = /* #__PURE__ */ (function () {

1551+ function ExprAdo(value0) {

1552+ this.value0 = value0;

1553+ };

1554+ ExprAdo.create = function (value0) {

1555+ return new ExprAdo(value0);

1556+ };

1557+ return ExprAdo;

1558+})();

1559+var ExprError = /* #__PURE__ */ (function () {

1560+ function ExprError(value0) {

1561+ this.value0 = value0;

1562+ };

1563+ ExprError.create = function (value0) {

1564+ return new ExprError(value0);

1565+ };

1566+ return ExprError;

1567+})();

1568+var RecordUpdateLeaf = /* #__PURE__ */ (function () {

1569+ function RecordUpdateLeaf(value0, value1, value2) {

1570+ this.value0 = value0;

1571+ this.value1 = value1;

1572+ this.value2 = value2;

1573+ };

1574+ RecordUpdateLeaf.create = function (value0) {

1575+ return function (value1) {

1576+ return function (value2) {

1577+ return new RecordUpdateLeaf(value0, value1, value2);

1578+ };

1579+ };

1580+ };

1581+ return RecordUpdateLeaf;

1582+})();

1583+var RecordUpdateBranch = /* #__PURE__ */ (function () {

1584+ function RecordUpdateBranch(value0, value1) {

1585+ this.value0 = value0;

1586+ this.value1 = value1;

1587+ };

1588+ RecordUpdateBranch.create = function (value0) {

1589+ return function (value1) {

1590+ return new RecordUpdateBranch(value0, value1);

1591+ };

1592+ };

1593+ return RecordUpdateBranch;

1594+})();

1595+var GuardedExpr = function (x) {

1596+ return x;

1597+};

1598+var PatternGuard = function (x) {

1599+ return x;

1600+};

1601+var InstanceBindingSignature = /* #__PURE__ */ (function () {

1602+ function InstanceBindingSignature(value0) {

1603+ this.value0 = value0;

1604+ };

1605+ InstanceBindingSignature.create = function (value0) {

1606+ return new InstanceBindingSignature(value0);

1607+ };

1608+ return InstanceBindingSignature;

1609+})();

1610+var InstanceBindingName = /* #__PURE__ */ (function () {

1611+ function InstanceBindingName(value0) {

1612+ this.value0 = value0;

1613+ };

1614+ InstanceBindingName.create = function (value0) {

1615+ return new InstanceBindingName(value0);

1616+ };

1617+ return InstanceBindingName;

1618+})();

1619+var Instance = function (x) {

1620+ return x;

1621+};

1622+var DeclData = /* #__PURE__ */ (function () {

1623+ function DeclData(value0, value1) {

1624+ this.value0 = value0;

1625+ this.value1 = value1;

1626+ };

1627+ DeclData.create = function (value0) {

1628+ return function (value1) {

1629+ return new DeclData(value0, value1);

1630+ };

1631+ };

1632+ return DeclData;

1633+})();

1634+var DeclType = /* #__PURE__ */ (function () {

1635+ function DeclType(value0, value1, value2) {

1636+ this.value0 = value0;

1637+ this.value1 = value1;

1638+ this.value2 = value2;

1639+ };

1640+ DeclType.create = function (value0) {

1641+ return function (value1) {

1642+ return function (value2) {

1643+ return new DeclType(value0, value1, value2);

1644+ };

1645+ };

1646+ };

1647+ return DeclType;

1648+})();

1649+var DeclNewtype = /* #__PURE__ */ (function () {

1650+ function DeclNewtype(value0, value1, value2, value3) {

1651+ this.value0 = value0;

1652+ this.value1 = value1;

1653+ this.value2 = value2;

1654+ this.value3 = value3;

1655+ };

1656+ DeclNewtype.create = function (value0) {

1657+ return function (value1) {

1658+ return function (value2) {

1659+ return function (value3) {

1660+ return new DeclNewtype(value0, value1, value2, value3);

1661+ };

1662+ };

1663+ };

1664+ };

1665+ return DeclNewtype;

1666+})();

1667+var DeclClass = /* #__PURE__ */ (function () {

1668+ function DeclClass(value0, value1) {

1669+ this.value0 = value0;

1670+ this.value1 = value1;

1671+ };

1672+ DeclClass.create = function (value0) {

1673+ return function (value1) {

1674+ return new DeclClass(value0, value1);

1675+ };

1676+ };

1677+ return DeclClass;

1678+})();

1679+var DeclInstanceChain = /* #__PURE__ */ (function () {

1680+ function DeclInstanceChain(value0) {

1681+ this.value0 = value0;

1682+ };

1683+ DeclInstanceChain.create = function (value0) {

1684+ return new DeclInstanceChain(value0);

1685+ };

1686+ return DeclInstanceChain;

1687+})();

1688+var DeclDerive = /* #__PURE__ */ (function () {

1689+ function DeclDerive(value0, value1, value2) {

1690+ this.value0 = value0;

1691+ this.value1 = value1;

1692+ this.value2 = value2;

1693+ };

1694+ DeclDerive.create = function (value0) {

1695+ return function (value1) {

1696+ return function (value2) {

1697+ return new DeclDerive(value0, value1, value2);

1698+ };

1699+ };

1700+ };

1701+ return DeclDerive;

1702+})();

1703+var DeclKindSignature = /* #__PURE__ */ (function () {

1704+ function DeclKindSignature(value0, value1) {

1705+ this.value0 = value0;

1706+ this.value1 = value1;

1707+ };

1708+ DeclKindSignature.create = function (value0) {

1709+ return function (value1) {

1710+ return new DeclKindSignature(value0, value1);

1711+ };

1712+ };

1713+ return DeclKindSignature;

1714+})();

1715+var DeclSignature = /* #__PURE__ */ (function () {

1716+ function DeclSignature(value0) {

1717+ this.value0 = value0;

1718+ };

1719+ DeclSignature.create = function (value0) {

1720+ return new DeclSignature(value0);

1721+ };

1722+ return DeclSignature;

1723+})();

1724+var DeclValue = /* #__PURE__ */ (function () {

1725+ function DeclValue(value0) {

1726+ this.value0 = value0;

1727+ };

1728+ DeclValue.create = function (value0) {

1729+ return new DeclValue(value0);

1730+ };

1731+ return DeclValue;

1732+})();

1733+var DeclFixity = /* #__PURE__ */ (function () {

1734+ function DeclFixity(value0) {

1735+ this.value0 = value0;

1736+ };

1737+ DeclFixity.create = function (value0) {

1738+ return new DeclFixity(value0);

1739+ };

1740+ return DeclFixity;

1741+})();

1742+var DeclForeign = /* #__PURE__ */ (function () {

1743+ function DeclForeign(value0, value1, value2) {

1744+ this.value0 = value0;

1745+ this.value1 = value1;

1746+ this.value2 = value2;

1747+ };

1748+ DeclForeign.create = function (value0) {

1749+ return function (value1) {

1750+ return function (value2) {

1751+ return new DeclForeign(value0, value1, value2);

1752+ };

1753+ };

1754+ };

1755+ return DeclForeign;

1756+})();

1757+var DeclRole = /* #__PURE__ */ (function () {

1758+ function DeclRole(value0, value1, value2, value3) {

1759+ this.value0 = value0;

1760+ this.value1 = value1;

1761+ this.value2 = value2;

1762+ this.value3 = value3;

1763+ };

1764+ DeclRole.create = function (value0) {

1765+ return function (value1) {

1766+ return function (value2) {

1767+ return function (value3) {

1768+ return new DeclRole(value0, value1, value2, value3);

1769+ };

1770+ };

1771+ };

1772+ };

1773+ return DeclRole;

1774+})();

1775+var DeclError = /* #__PURE__ */ (function () {

1776+ function DeclError(value0) {

1777+ this.value0 = value0;

1778+ };

1779+ DeclError.create = function (value0) {

1780+ return new DeclError(value0);

1781+ };

1782+ return DeclError;

1783+})();

1784+var ModuleBody = function (x) {

1785+ return x;

1786+};

1787+var Module = function (x) {

1788+ return x;

1789+};

1790+var ordProper = Data_Ord.ordString;

1791+var ordOperator = Data_Ord.ordString;

1792+var ordModuleName = Data_Ord.ordString;

1793+var ordLabel = Data_Ord.ordString;

1794+var ordIdent = Data_Ord.ordString;

1795+var newtypeWrapped = {

1796+ Coercible0: function () {

1797+ return undefined;

1798+ }

1799+};

1800+var newtypeWhere = {

1801+ Coercible0: function () {

1802+ return undefined;

1803+ }

1804+};

1805+var newtypeSeparated = {

1806+ Coercible0: function () {

1807+ return undefined;

1808+ }

1809+};

1810+var newtypeRow = {

1811+ Coercible0: function () {

1812+ return undefined;

1813+ }

1814+};

1815+var newtypeQualifiedName = {

1816+ Coercible0: function () {

1817+ return undefined;

1818+ }

1819+};

1820+var newtypeProper = {

1821+ Coercible0: function () {

1822+ return undefined;

1823+ }

1824+};

1825+var newtypePrefixed = {

1826+ Coercible0: function () {

1827+ return undefined;

1828+ }

1829+};

1830+var newtypePatternGuard = {

1831+ Coercible0: function () {

1832+ return undefined;

1833+ }

1834+};

1835+var newtypeOperator = {

1836+ Coercible0: function () {

1837+ return undefined;

1838+ }

1839+};

1840+var newtypeName = {

1841+ Coercible0: function () {

1842+ return undefined;

1843+ }

1844+};

1845+var newtypeModuleName = {

1846+ Coercible0: function () {

1847+ return undefined;

1848+ }

1849+};

1850+var newtypeModuleHeader = {

1851+ Coercible0: function () {

1852+ return undefined;

1853+ }

1854+};

1855+var newtypeModuleBody = {

1856+ Coercible0: function () {

1857+ return undefined;

1858+ }

1859+};

1860+var newtypeModule = {

1861+ Coercible0: function () {

1862+ return undefined;

1863+ }

1864+};

1865+var newtypeLabeled = {

1866+ Coercible0: function () {

1867+ return undefined;

1868+ }

1869+};

1870+var newtypeLabel = {

1871+ Coercible0: function () {

1872+ return undefined;

1873+ }

1874+};

1875+var newtypeInstance = {

1876+ Coercible0: function () {

1877+ return undefined;

1878+ }

1879+};

1880+var newtypeImportDecl = {

1881+ Coercible0: function () {

1882+ return undefined;

1883+ }

1884+};

1885+var newtypeIdent = {

1886+ Coercible0: function () {

1887+ return undefined;

1888+ }

1889+};

1890+var newtypeGuardedExpr = {

1891+ Coercible0: function () {

1892+ return undefined;

1893+ }

1894+};

1895+var newtypeDataCtor = {

1896+ Coercible0: function () {

1897+ return undefined;

1898+ }

1899+};

1900+var eqSourceStyle = {

1901+ eq: function (x) {

1902+ return function (y) {

1903+ if (x instanceof ASCII && y instanceof ASCII) {

1904+ return true;

1905+ };

1906+ if (x instanceof Unicode && y instanceof Unicode) {

1907+ return true;

1908+ };

1909+ return false;

1910+ };

1911+ }

1912+};

1913+var eq4 = /* #__PURE__ */ Data_Eq.eq(eqSourceStyle);

1914+var eqProper = Data_Eq.eqString;

1915+var eqOperator = Data_Eq.eqString;

1916+var eqModuleName = Data_Eq.eqString;

1917+var eq5 = /* #__PURE__ */ Data_Eq.eq(/* #__PURE__ */ Data_Maybe.eqMaybe(eqModuleName));

1918+var eqLabel = Data_Eq.eqString;

1919+var eqIntValue = {

1920+ eq: function (x) {

1921+ return function (y) {

1922+ if (x instanceof SmallInt && y instanceof SmallInt) {

1923+ return x.value0 === y.value0;

1924+ };

1925+ if (x instanceof BigInt && y instanceof BigInt) {

1926+ return x.value0 === y.value0;

1927+ };

1928+ if (x instanceof BigHex && y instanceof BigHex) {

1929+ return x.value0 === y.value0;

1930+ };

1931+ return false;

1932+ };

1933+ }

1934+};

1935+var eq6 = /* #__PURE__ */ Data_Eq.eq(eqIntValue);

1936+var eqToken = {

1937+ eq: function (x) {

1938+ return function (y) {

1939+ if (x instanceof TokLeftParen && y instanceof TokLeftParen) {

1940+ return true;

1941+ };

1942+ if (x instanceof TokRightParen && y instanceof TokRightParen) {

1943+ return true;

1944+ };

1945+ if (x instanceof TokLeftBrace && y instanceof TokLeftBrace) {

1946+ return true;

1947+ };

1948+ if (x instanceof TokRightBrace && y instanceof TokRightBrace) {

1949+ return true;

1950+ };

1951+ if (x instanceof TokLeftSquare && y instanceof TokLeftSquare) {

1952+ return true;

1953+ };

1954+ if (x instanceof TokRightSquare && y instanceof TokRightSquare) {

1955+ return true;

1956+ };

1957+ if (x instanceof TokLeftArrow && y instanceof TokLeftArrow) {

1958+ return eq4(x.value0)(y.value0);

1959+ };

1960+ if (x instanceof TokRightArrow && y instanceof TokRightArrow) {

1961+ return eq4(x.value0)(y.value0);

1962+ };

1963+ if (x instanceof TokRightFatArrow && y instanceof TokRightFatArrow) {

1964+ return eq4(x.value0)(y.value0);

1965+ };

1966+ if (x instanceof TokDoubleColon && y instanceof TokDoubleColon) {

1967+ return eq4(x.value0)(y.value0);

1968+ };

1969+ if (x instanceof TokForall && y instanceof TokForall) {

1970+ return eq4(x.value0)(y.value0);

1971+ };

1972+ if (x instanceof TokEquals && y instanceof TokEquals) {

1973+ return true;

1974+ };

1975+ if (x instanceof TokPipe && y instanceof TokPipe) {

1976+ return true;

1977+ };

1978+ if (x instanceof TokTick && y instanceof TokTick) {

1979+ return true;

1980+ };

1981+ if (x instanceof TokDot && y instanceof TokDot) {

1982+ return true;

1983+ };

1984+ if (x instanceof TokComma && y instanceof TokComma) {

1985+ return true;

1986+ };

1987+ if (x instanceof TokUnderscore && y instanceof TokUnderscore) {

1988+ return true;

1989+ };

1990+ if (x instanceof TokBackslash && y instanceof TokBackslash) {

1991+ return true;

1992+ };

1993+ if (x instanceof TokAt && y instanceof TokAt) {

1994+ return true;

1995+ };

1996+ if (x instanceof TokLowerName && y instanceof TokLowerName) {

1997+ return eq5(x.value0)(y.value0) && x.value1 === y.value1;

1998+ };

1999+ if (x instanceof TokUpperName && y instanceof TokUpperName) {

2000+ return eq5(x.value0)(y.value0) && x.value1 === y.value1;

2001+ };

2002+ if (x instanceof TokOperator && y instanceof TokOperator) {

2003+ return eq5(x.value0)(y.value0) && x.value1 === y.value1;

2004+ };

2005+ if (x instanceof TokSymbolName && y instanceof TokSymbolName) {

2006+ return eq5(x.value0)(y.value0) && x.value1 === y.value1;

2007+ };

2008+ if (x instanceof TokSymbolArrow && y instanceof TokSymbolArrow) {

2009+ return eq4(x.value0)(y.value0);

2010+ };

2011+ if (x instanceof TokHole && y instanceof TokHole) {

2012+ return x.value0 === y.value0;

2013+ };

2014+ if (x instanceof TokChar && y instanceof TokChar) {

2015+ return x.value0 === y.value0 && x.value1 === y.value1;

2016+ };

2017+ if (x instanceof TokString && y instanceof TokString) {

2018+ return x.value0 === y.value0 && x.value1 === y.value1;

2019+ };

2020+ if (x instanceof TokRawString && y instanceof TokRawString) {

2021+ return x.value0 === y.value0;

2022+ };

2023+ if (x instanceof TokInt && y instanceof TokInt) {

2024+ return x.value0 === y.value0 && eq6(x.value1)(y.value1);

2025+ };

2026+ if (x instanceof TokNumber && y instanceof TokNumber) {

2027+ return x.value0 === y.value0 && x.value1 === y.value1;

2028+ };

2029+ if (x instanceof TokLayoutStart && y instanceof TokLayoutStart) {

2030+ return x.value0 === y.value0;

2031+ };

2032+ if (x instanceof TokLayoutSep && y instanceof TokLayoutSep) {

2033+ return x.value0 === y.value0;

2034+ };

2035+ if (x instanceof TokLayoutEnd && y instanceof TokLayoutEnd) {

2036+ return x.value0 === y.value0;

2037+ };

2038+ return false;

2039+ };

2040+ }

2041+};

2042+var eqIdent = Data_Eq.eqString;

2043+export {

2044+ ModuleName,

2045+ Comment,

2046+ Space,

2047+ Line,

2048+ LF,

2049+ CRLF,

2050+ ASCII,

2051+ Unicode,

2052+ SmallInt,

2053+ BigInt,

2054+ BigHex,

2055+ TokLeftParen,

2056+ TokRightParen,

2057+ TokLeftBrace,

2058+ TokRightBrace,

2059+ TokLeftSquare,

2060+ TokRightSquare,

2061+ TokLeftArrow,

2062+ TokRightArrow,

2063+ TokRightFatArrow,

2064+ TokDoubleColon,

2065+ TokForall,

2066+ TokEquals,

2067+ TokPipe,

2068+ TokTick,

2069+ TokDot,

2070+ TokComma,

2071+ TokUnderscore,

2072+ TokBackslash,

2073+ TokAt,

2074+ TokLowerName,

2075+ TokUpperName,

2076+ TokOperator,

2077+ TokSymbolName,

2078+ TokSymbolArrow,

2079+ TokHole,

2080+ TokChar,

2081+ TokString,

2082+ TokRawString,

2083+ TokInt,

2084+ TokNumber,

2085+ TokLayoutStart,

2086+ TokLayoutSep,

2087+ TokLayoutEnd,

2088+ Ident,

2089+ Proper,

2090+ Label,

2091+ Operator,

2092+ Name,

2093+ QualifiedName,

2094+ Wrapped,

2095+ Separated,

2096+ Labeled,

2097+ Prefixed,

2098+ One,

2099+ Many,

2100+ TypeVar,

2101+ TypeConstructor,

2102+ TypeWildcard,

2103+ TypeHole,

2104+ TypeString,

2105+ TypeInt,

2106+ TypeRow,

2107+ TypeRecord,

2108+ TypeForall,

2109+ TypeKinded,

2110+ TypeApp,

2111+ TypeOp,

2112+ TypeOpName,

2113+ TypeArrow,

2114+ TypeArrowName,

2115+ TypeConstrained,

2116+ TypeParens,

2117+ $$TypeError as TypeError,

2118+ TypeVarKinded,

2119+ TypeVarName,

2120+ Row,

2121+ Module,

2122+ ModuleHeader,

2123+ ModuleBody,

2124+ ExportValue,

2125+ ExportOp,

2126+ ExportType,

2127+ ExportTypeOp,

2128+ ExportClass,

2129+ ExportModule,

2130+ ExportError,

2131+ DataAll,

2132+ DataEnumerated,

2133+ DeclData,

2134+ DeclType,

2135+ DeclNewtype,

2136+ DeclClass,

2137+ DeclInstanceChain,

2138+ DeclDerive,

2139+ DeclKindSignature,

2140+ DeclSignature,

2141+ DeclValue,

2142+ DeclFixity,

2143+ DeclForeign,

2144+ DeclRole,

2145+ DeclError,

2146+ Instance,

2147+ InstanceBindingSignature,

2148+ InstanceBindingName,

2149+ ImportDecl,

2150+ ImportValue,

2151+ ImportOp,

2152+ ImportType,

2153+ ImportTypeOp,

2154+ ImportClass,

2155+ ImportError,

2156+ DataCtor,

2157+ FundepDetermined,

2158+ FundepDetermines,

2159+ Infix,

2160+ Infixl,

2161+ Infixr,

2162+ FixityValue,

2163+ FixityType,

2164+ Unconditional,

2165+ Guarded,

2166+ GuardedExpr,

2167+ PatternGuard,

2168+ ForeignValue,

2169+ ForeignData,

2170+ ForeignKind,

2171+ Nominal,

2172+ Representational,

2173+ Phantom,

2174+ ExprHole,

2175+ ExprSection,

2176+ ExprIdent,

2177+ ExprConstructor,

2178+ ExprBoolean,

2179+ ExprChar,

2180+ ExprString,

2181+ ExprInt,

2182+ ExprNumber,

2183+ ExprArray,

2184+ ExprRecord,

2185+ ExprParens,

2186+ ExprTyped,

2187+ ExprInfix,

2188+ ExprOp,

2189+ ExprOpName,

2190+ ExprNegate,

2191+ ExprRecordAccessor,

2192+ ExprRecordUpdate,

2193+ ExprApp,

2194+ ExprLambda,

2195+ ExprIf,

2196+ ExprCase,

2197+ ExprLet,

2198+ ExprDo,

2199+ ExprAdo,

2200+ ExprError,

2201+ AppType,

2202+ AppTerm,

2203+ RecordPun,

2204+ RecordField,

2205+ RecordUpdateLeaf,

2206+ RecordUpdateBranch,

2207+ Where,

2208+ LetBindingSignature,

2209+ LetBindingName,

2210+ LetBindingPattern,

2211+ LetBindingError,

2212+ DoLet,

2213+ DoDiscard,

2214+ DoBind,

2215+ DoError,

2216+ BinderWildcard,

2217+ BinderVar,

2218+ BinderNamed,

2219+ BinderConstructor,

2220+ BinderBoolean,

2221+ BinderChar,

2222+ BinderString,

2223+ BinderInt,

2224+ BinderNumber,

2225+ BinderArray,

2226+ BinderRecord,

2227+ BinderParens,

2228+ BinderTyped,

2229+ BinderOp,

2230+ BinderError,

2231+ eqModuleName,

2232+ ordModuleName,

2233+ newtypeModuleName,

2234+ eqSourceStyle,

2235+ eqIntValue,

2236+ eqToken,

2237+ eqIdent,

2238+ ordIdent,

2239+ newtypeIdent,

2240+ eqProper,

2241+ ordProper,

2242+ newtypeProper,

2243+ eqLabel,

2244+ ordLabel,

2245+ newtypeLabel,

2246+ eqOperator,

2247+ ordOperator,

2248+ newtypeOperator,

2249+ newtypeName,

2250+ newtypeQualifiedName,

2251+ newtypeWrapped,

2252+ newtypeSeparated,

2253+ newtypeLabeled,

2254+ newtypePrefixed,

2255+ newtypeRow,

2256+ newtypeModule,

2257+ newtypeModuleHeader,

2258+ newtypeModuleBody,

2259+ newtypeInstance,

2260+ newtypeImportDecl,

2261+ newtypeDataCtor,

2262+ newtypeGuardedExpr,

2263+ newtypePatternGuard,

2264+ newtypeWhere

2265+};

output-compile-fail/PureScript.CST/externs.cbornew file

Binary file not shown.

output-compile-fail/PureScript.CST/index.jsnew file+163

@@ -0,0 +1,163 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Applicative from "../Control.Applicative/index.js";

3+import * as Control_Bind from "../Control.Bind/index.js";

4+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

5+import * as Data_Boolean from "../Data.Boolean/index.js";

6+import * as Data_Either from "../Data.Either/index.js";

7+import * as Data_Foldable from "../Data.Foldable/index.js";

8+import * as Data_Function from "../Data.Function/index.js";

9+import * as Data_Lazy from "../Data.Lazy/index.js";

10+import * as Data_Maybe from "../Data.Maybe/index.js";

11+import * as Data_Monoid from "../Data.Monoid/index.js";

12+import * as Data_Newtype from "../Data.Newtype/index.js";

13+import * as Data_Tuple from "../Data.Tuple/index.js";

14+import * as PureScript_CST_Lexer from "../PureScript.CST.Lexer/index.js";

15+import * as PureScript_CST_Parser from "../PureScript.CST.Parser/index.js";

16+import * as PureScript_CST_Parser_Monad from "../PureScript.CST.Parser.Monad/index.js";

17+import * as PureScript_CST_Print from "../PureScript.CST.Print/index.js";

18+import * as PureScript_CST_Range from "../PureScript.CST.Range/index.js";

19+import * as PureScript_CST_Range_TokenList from "../PureScript.CST.Range.TokenList/index.js";

20+import * as Unsafe_Coerce from "../Unsafe.Coerce/index.js";

21+var foldMap = /* #__PURE__ */ Data_Foldable.foldMap(Data_Foldable.foldableArray)(Data_Monoid.monoidString);

22+var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();

23+var bind = /* #__PURE__ */ Control_Bind.bind(PureScript_CST_Parser_Monad.bindParser);

24+var pure = /* #__PURE__ */ Control_Applicative.pure(PureScript_CST_Parser_Monad.applicativeParser);

25+var ParseSucceeded = /* #__PURE__ */ (function () {

26+ function ParseSucceeded(value0) {

27+ this.value0 = value0;

28+ };

29+ ParseSucceeded.create = function (value0) {

30+ return new ParseSucceeded(value0);

31+ };

32+ return ParseSucceeded;

33+})();

34+var ParseSucceededWithErrors = /* #__PURE__ */ (function () {

35+ function ParseSucceededWithErrors(value0, value1) {

36+ this.value0 = value0;

37+ this.value1 = value1;

38+ };

39+ ParseSucceededWithErrors.create = function (value0) {

40+ return function (value1) {

41+ return new ParseSucceededWithErrors(value0, value1);

42+ };

43+ };

44+ return ParseSucceededWithErrors;

45+})();

46+var ParseFailed = /* #__PURE__ */ (function () {

47+ function ParseFailed(value0) {

48+ this.value0 = value0;

49+ };

50+ ParseFailed.create = function (value0) {

51+ return new ParseFailed(value0);

52+ };

53+ return ParseFailed;

54+})();

55+var PartialModule = function (x) {

56+ return x;

57+};

58+var toRecoveredParserResult = function (v) {

59+ var v1 = function (v2) {

60+ if (v instanceof Data_Either.Right && Data_Boolean.otherwise) {

61+ return new ParseSucceeded(v.value0.value0);

62+ };

63+ if (v instanceof Data_Either.Left) {

64+ return new ParseFailed(v.value0);

65+ };

66+ throw new Error("Failed pattern match at PureScript.CST (line 42, column 1 - line 45, column 29): " + [ v.constructor.name ]);

67+ };

68+ if (v instanceof Data_Either.Right) {

69+ var $21 = Data_Array_NonEmpty.fromArray(v.value0.value1);

70+ if ($21 instanceof Data_Maybe.Just) {

71+ return new ParseSucceededWithErrors(v.value0.value0, $21.value0);

72+ };

73+ return v1(true);

74+ };

75+ return v1(true);

76+};

77+var toRecovered = Unsafe_Coerce.unsafeCoerce;

78+var runRecoveredParser = function (p) {

79+ var $31 = Data_Function.flip(PureScript_CST_Parser_Monad.runParser)(p);

80+ return function ($32) {

81+ return toRecoveredParserResult($31($32));

82+ };

83+};

84+var printModule = function (dictTokensOf) {

85+ var tokensOf = PureScript_CST_Range.tokensOf(PureScript_CST_Range.tokensOfModule(dictTokensOf));

86+ return function (mod) {

87+ return foldMap(PureScript_CST_Print.printSourceToken)(PureScript_CST_Range_TokenList.toArray(tokensOf(mod))) + foldMap(PureScript_CST_Print.printComment(PureScript_CST_Print.printLineFeed))((unwrap((unwrap(mod)).body)).trailingComments);

88+ };

89+};

90+var parseType = /* #__PURE__ */ (function () {

91+ var $33 = runRecoveredParser(PureScript_CST_Parser.parseType);

92+ return function ($34) {

93+ return $33(PureScript_CST_Lexer.lex($34));

94+ };

95+})();

96+var parsePartialModule = function (src) {

97+ return toRecoveredParserResult((function () {

98+ var v = PureScript_CST_Parser_Monad["runParser$prime"](PureScript_CST_Parser_Monad.initialParserState(PureScript_CST_Lexer.lexModule(src)))(PureScript_CST_Parser.parseModuleHeader);

99+ if (v instanceof PureScript_CST_Parser_Monad.ParseSucc) {

100+ var res = {

101+ header: v.value0,

102+ full: Data_Lazy.defer(function (v1) {

103+ return toRecoveredParserResult(PureScript_CST_Parser_Monad.fromParserResult(PureScript_CST_Parser_Monad["runParser$prime"](v.value1)(bind(PureScript_CST_Parser.parseModuleBody)(function (body) {

104+ return pure({

105+ header: v.value0,

106+ body: body

107+ });

108+ }))));

109+ })

110+ };

111+ return new Data_Either.Right(new Data_Tuple.Tuple(res, v.value1.errors));

112+ };

113+ if (v instanceof PureScript_CST_Parser_Monad.ParseFail) {

114+ return new Data_Either.Left(v.value0);

115+ };

116+ throw new Error("Failed pattern match at PureScript.CST (line 86, column 29 - line 98, column 17): " + [ v.constructor.name ]);

117+ })());

118+};

119+var parseModule = /* #__PURE__ */ (function () {

120+ var $35 = runRecoveredParser(PureScript_CST_Parser.parseModule);

121+ return function ($36) {

122+ return $35(PureScript_CST_Lexer.lexModule($36));

123+ };

124+})();

125+var parseImportDecl = /* #__PURE__ */ (function () {

126+ var $37 = runRecoveredParser(PureScript_CST_Parser.parseImportDecl);

127+ return function ($38) {

128+ return $37(PureScript_CST_Lexer.lex($38));

129+ };

130+})();

131+var parseExpr = /* #__PURE__ */ (function () {

132+ var $39 = runRecoveredParser(PureScript_CST_Parser.parseExpr);

133+ return function ($40) {

134+ return $39(PureScript_CST_Lexer.lex($40));

135+ };

136+})();

137+var parseDecl = /* #__PURE__ */ (function () {

138+ var $41 = runRecoveredParser(PureScript_CST_Parser.parseDecl);

139+ return function ($42) {

140+ return $41(PureScript_CST_Lexer.lex($42));

141+ };

142+})();

143+var parseBinder = /* #__PURE__ */ (function () {

144+ var $43 = runRecoveredParser(PureScript_CST_Parser.parseBinder);

145+ return function ($44) {

146+ return $43(PureScript_CST_Lexer.lex($44));

147+ };

148+})();

149+export {

150+ ParseSucceeded,

151+ ParseSucceededWithErrors,

152+ ParseFailed,

153+ PartialModule,

154+ parseModule,

155+ parsePartialModule,

156+ parseImportDecl,

157+ parseDecl,

158+ parseExpr,

159+ parseType,

160+ parseBinder,

161+ printModule,

162+ toRecovered

163+};

output-compile-fail/Tidy.Codegen.Class/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.Class/index.jsnew file+1563

@@ -0,0 +1,1563 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Applicative from "../Control.Applicative/index.js";

3+import * as Control_Bind from "../Control.Bind/index.js";

4+import * as Control_Category from "../Control.Category/index.js";

5+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

6+import * as Data_Array_NonEmpty_Internal from "../Data.Array.NonEmpty.Internal/index.js";

7+import * as Data_Bifunctor from "../Data.Bifunctor/index.js";

8+import * as Data_Either from "../Data.Either/index.js";

9+import * as Data_Function from "../Data.Function/index.js";

10+import * as Data_Functor from "../Data.Functor/index.js";

11+import * as Data_Maybe from "../Data.Maybe/index.js";

12+import * as Data_Newtype from "../Data.Newtype/index.js";

13+import * as Data_Show from "../Data.Show/index.js";

14+import * as Data_String_CodePoints from "../Data.String.CodePoints/index.js";

15+import * as Data_Tuple from "../Data.Tuple/index.js";

16+import * as Data_Void from "../Data.Void/index.js";

17+import * as Partial from "../Partial/index.js";

18+import * as PureScript_CST_Lexer from "../PureScript.CST.Lexer/index.js";

19+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

20+import * as Safe_Coerce from "../Safe.Coerce/index.js";

21+import * as Tidy_Codegen_Common from "../Tidy.Codegen.Common/index.js";

22+import * as Tidy_Codegen_String from "../Tidy.Codegen.String/index.js";

23+import * as Tidy_Codegen_Types from "../Tidy.Codegen.Types/index.js";

24+import * as Type_Equality from "../Type.Equality/index.js";

25+var identity = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);

26+var unwrap = /* #__PURE__ */ Data_Newtype.unwrap();

27+var crashWith = /* #__PURE__ */ Partial.crashWith();

28+var show = /* #__PURE__ */ Data_Show.show(Data_Show.showNumber);

29+var bind = /* #__PURE__ */ Control_Bind.bind(Data_Maybe.bindMaybe);

30+var pure = /* #__PURE__ */ Control_Applicative.pure(Data_Maybe.applicativeMaybe);

31+var show1 = /* #__PURE__ */ Data_Show.show(Data_Show.showInt);

32+var coerce = /* #__PURE__ */ Safe_Coerce.coerce();

33+var map = /* #__PURE__ */ Data_Functor.map(Data_Array_NonEmpty_Internal.functorNonEmptyArray);

34+var lmap = /* #__PURE__ */ Data_Bifunctor.lmap(Data_Bifunctor.bifunctorTuple);

35+var over = /* #__PURE__ */ Data_Newtype.over()();

36+var ErrorPrefix = function (x) {

37+ return x;

38+};

39+var toWhereWhere = {

40+ toWhere: identity

41+};

42+var toWhereExpr = {

43+ toWhere: function ($711) {

44+ return PureScript_CST_Types.Where((function (v) {

45+ return {

46+ bindings: Data_Maybe.Nothing.value,

47+ expr: v

48+ };

49+ })($711));

50+ }

51+};

52+var toTokenSymbolNameSymbolNa = {

53+ toToken: function (str) {

54+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, unwrap(str)), str);

55+ }

56+};

57+var toTokenSymbolNameOperator = {

58+ toToken: function (str) {

59+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, unwrap(str)), unwrap(str));

60+ }

61+};

62+var toTokenStringSymbolName = function () {

63+ return {

64+ toToken: function (str) {

65+ var v = PureScript_CST_Lexer.lexToken(str);

66+ if (v instanceof Data_Either.Right && (v.value0 instanceof PureScript_CST_Types.TokSymbolName && v.value0.value0 instanceof Data_Maybe.Nothing)) {

67+ return new Data_Tuple.Tuple(v.value0, v.value0.value1);

68+ };

69+ if (v instanceof Data_Either.Right && (v.value0 instanceof PureScript_CST_Types.TokOperator && v.value0.value0 instanceof Data_Maybe.Nothing)) {

70+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, v.value0.value1), str);

71+ };

72+ return crashWith("Not a SymbolName: " + str);

73+ }

74+ };

75+};

76+var toTokenStringString = {

77+ toToken: function (str) {

78+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokString(unwrap(Tidy_Codegen_String.escapeSourceString(str)), str), str);

79+ }

80+};

81+var toTokenRoleRole = {

82+ toToken: function (role) {

83+ return new Data_Tuple.Tuple((Tidy_Codegen_Common.tokForRole(role)).value, role);

84+ }

85+};

86+var toTokenQualifiedSymbolNam = {

87+ toToken: function (v) {

88+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokSymbolName(v.value0, unwrap(v.value1)), v);

89+ }

90+};

91+var toTokenQualifiedProperQua = {

92+ toToken: function (v) {

93+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokUpperName(v.value0, unwrap(v.value1)), v);

94+ }

95+};

96+var toTokenQualifiedOperatorQ = {

97+ toToken: function (v) {

98+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokOperator(v.value0, unwrap(v.value1)), v);

99+ }

100+};

101+var toTokenQualifiedNameQuali = {

102+ toToken: function (v) {

103+ return new Data_Tuple.Tuple(v.token.value, new Tidy_Codegen_Types.Qualified(v.module, v.name));

104+ }

105+};

106+var toTokenQualifiedIdentQual = {

107+ toToken: function (v) {

108+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokLowerName(v.value0, unwrap(v.value1)), v);

109+ }

110+};

111+var toTokenProperProper = {

112+ toToken: function (str) {

113+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokUpperName(Data_Maybe.Nothing.value, unwrap(str)), str);

114+ }

115+};

116+var toTokenOperatorOperator = {

117+ toToken: function (str) {

118+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokOperator(Data_Maybe.Nothing.value, unwrap(str)), str);

119+ }

120+};

121+var toTokenNumberNumber = {

122+ toToken: function (n) {

123+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokNumber(show(n), n), n);

124+ }

125+};

126+var toTokenNameSymbolNameSymb = {

127+ toToken: function (v) {

128+ return new Data_Tuple.Tuple(v.token.value, v.name);

129+ }

130+};

131+var toTokenNameSymbolNameQual = {

132+ toToken: function (v) {

133+ return new Data_Tuple.Tuple(v.token.value, new Tidy_Codegen_Types.Qualified(Data_Maybe.Nothing.value, v.name));

134+ }

135+};

136+var toTokenNameProperQualifie = {

137+ toToken: function (v) {

138+ return new Data_Tuple.Tuple(v.token.value, new Tidy_Codegen_Types.Qualified(Data_Maybe.Nothing.value, v.name));

139+ }

140+};

141+var toTokenNameProperProper = {

142+ toToken: function (v) {

143+ return new Data_Tuple.Tuple(v.token.value, v.name);

144+ }

145+};

146+var toTokenNameOperatorQualif = {

147+ toToken: function (v) {

148+ return new Data_Tuple.Tuple(v.token.value, new Tidy_Codegen_Types.Qualified(Data_Maybe.Nothing.value, v.name));

149+ }

150+};

151+var toTokenNameOperatorOperat = {

152+ toToken: function (v) {

153+ return new Data_Tuple.Tuple(v.token.value, v.name);

154+ }

155+};

156+var toTokenNameModuleNameModu = {

157+ toToken: function (v) {

158+ return new Data_Tuple.Tuple(v.token.value, v.name);

159+ }

160+};

161+var toTokenNameLabelLabel = {

162+ toToken: function (v) {

163+ return new Data_Tuple.Tuple(v.token.value, v.name);

164+ }

165+};

166+var toTokenNameIdentQualified = {

167+ toToken: function (v) {

168+ return new Data_Tuple.Tuple(v.token.value, new Tidy_Codegen_Types.Qualified(Data_Maybe.Nothing.value, v.name));

169+ }

170+};

171+var toTokenNameIdentIdent = {

172+ toToken: function (v) {

173+ return new Data_Tuple.Tuple(v.token.value, v.name);

174+ }

175+};

176+var toTokenModuleNameModuleNa = {

177+ toToken: function (v) {

178+ var token = Data_Maybe.fromMaybe(new PureScript_CST_Types.TokUpperName(Data_Maybe.Nothing.value, v))(bind(Data_String_CodePoints.lastIndexOf(".")(v))(function (ix) {

179+ var qual = Data_String_CodePoints.take(ix)(v);

180+ var mod = Data_String_CodePoints.drop(ix + 1 | 0)(v);

181+ return pure(new PureScript_CST_Types.TokUpperName(new Data_Maybe.Just(qual), mod));

182+ }));

183+ return new Data_Tuple.Tuple(token, v);

184+ }

185+};

186+var toTokenLabelLabel = {

187+ toToken: function (v) {

188+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokString(unwrap(Tidy_Codegen_String.escapeSourceString(v)), v), v);

189+ }

190+};

191+var toTokenIntIntValue = {

192+ toToken: function (n) {

193+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokInt(show1(n), new PureScript_CST_Types.SmallInt(n)), new PureScript_CST_Types.SmallInt(n));

194+ }

195+};

196+var toTokenIntInt = {

197+ toToken: function (n) {

198+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokInt(show1(n), new PureScript_CST_Types.SmallInt(n)), n);

199+ }

200+};

201+var toTokenIdentIdent = {

202+ toToken: function (str) {

203+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokLowerName(Data_Maybe.Nothing.value, unwrap(str)), str);

204+ }

205+};

206+var toTokenFixityFixity = {

207+ toToken: function (fixity) {

208+ return new Data_Tuple.Tuple((Tidy_Codegen_Common.tokForFixity(fixity)).value, fixity);

209+ }

210+};

211+var toTokenBooleanBoolean = {

212+ toToken: function (b) {

213+ return new Data_Tuple.Tuple(new PureScript_CST_Types.TokLowerName(Data_Maybe.Nothing.value, (function () {

214+ if (b) {

215+ return "true";

216+ };

217+ return "false";

218+ })()), b);

219+ }

220+};

221+var toRecordLabeledRecordLabe = function (dictTypeEquals) {

222+ return {

223+ toRecordLabeled: Type_Equality.proof(dictTypeEquals)

224+ };

225+};

226+var toRecordLabeledNameIdent = /* #__PURE__ */ (function () {

227+ return {

228+ toRecordLabeled: PureScript_CST_Types.RecordPun.create

229+ };

230+})();

231+var toQualifiedNameQualifiedN = {

232+ toQualifiedName: identity

233+};

234+var toQualifiedNameQualifiedN1 = {

235+ toQualifiedName: function (v) {

236+ if (v.token.value instanceof PureScript_CST_Types.TokOperator) {

237+ return {

238+ module: v.token.value.value0,

239+ token: Tidy_Codegen_Common.toSourceToken(new PureScript_CST_Types.TokSymbolName(v.token.value.value0, v.token.value.value1)),

240+ name: v.token.value.value1

241+ };

242+ };

243+ return {

244+ token: v.token,

245+ module: v.module,

246+ name: coerce(v.name)

247+ };

248+ }

249+};

250+var toQualifiedNameQualifiedN2 = {

251+ toQualifiedName: function (v) {

252+ if (v.token.value instanceof PureScript_CST_Types.TokSymbolName) {

253+ return {

254+ module: v.token.value.value0,

255+ token: Tidy_Codegen_Common.toSourceToken(new PureScript_CST_Types.TokOperator(v.token.value.value0, v.token.value.value1)),

256+ name: v.token.value.value1

257+ };

258+ };

259+ return {

260+ token: v.token,

261+ module: v.module,

262+ name: coerce(v.name)

263+ };

264+ }

265+};

266+var toQualifiedNameName = {

267+ toQualifiedName: function (v) {

268+ return {

269+ module: Data_Maybe.Nothing.value,

270+ name: v.name,

271+ token: v.token

272+ };

273+ }

274+};

275+var toNonEmptyArrayNonEmptyAr = {

276+ toNonEmptyArray: /* #__PURE__ */ Data_Function["const"](identity)

277+};

278+var toNonEmptyArrayArray = function () {

279+ return {

280+ toNonEmptyArray: function (v) {

281+ return function (a) {

282+ var v1 = Data_Array_NonEmpty.fromArray(a);

283+ if (v1 instanceof Data_Maybe.Just) {

284+ return v1.value0;

285+ };

286+ if (v1 instanceof Data_Maybe.Nothing) {

287+ return crashWith(v + ": Array is empty");

288+ };

289+ throw new Error("Failed pattern match at Tidy.Codegen.Class (line 30, column 47 - line 32, column 59): " + [ v1.constructor.name ]);

290+ };

291+ }

292+ };

293+};

294+var toNameQualifiedName = {

295+ toName: function (v) {

296+ return {

297+ name: v.name,

298+ token: v.token

299+ };

300+ }

301+};

302+var toNameOperatorSymbolName = {

303+ toName: function (str) {

304+ return {

305+ name: coerce(str),

306+ token: Tidy_Codegen_Common.toSourceToken(new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, unwrap(str)))

307+ };

308+ }

309+};

310+var toNameNameProperProper = {

311+ toName: identity

312+};

313+var toNameNameOperatorSymbolN = {

314+ toName: function (v) {

315+ return {

316+ name: coerce(v.name),

317+ token: (function () {

318+ if (v.token.value instanceof PureScript_CST_Types.TokOperator) {

319+ return {

320+ range: v.token.range,

321+ leadingComments: v.token.leadingComments,

322+ trailingComments: v.token.trailingComments,

323+ value: new PureScript_CST_Types.TokSymbolName(v.token.value.value0, v.token.value.value1)

324+ };

325+ };

326+ return v.token;

327+ })()

328+ };

329+ }

330+};

331+var toNameNameOperatorOperato = {

332+ toName: identity

333+};

334+var toNameNameIdentIdent = {

335+ toName: identity

336+};

337+var toModuleNameModuleName = {

338+ toModuleName: identity

339+};

340+var toGuardedWhere = /* #__PURE__ */ (function () {

341+ return {

342+ toGuarded: PureScript_CST_Types.Unconditional.create

343+ };

344+})();

345+var toGuardedNonEmptyArray = function (dictTypeEquals) {

346+ var to = Type_Equality.to(dictTypeEquals);

347+ return {

348+ toGuarded: function (tok) {

349+ var go = function (v) {

350+ return {

351+ bar: Tidy_Codegen_Common.tokPipe,

352+ patterns: Tidy_Codegen_Common.toSeparated(Tidy_Codegen_Common.tokComma)(v.value0),

353+ separator: tok,

354+ where: v.value1

355+ };

356+ };

357+ var $712 = map(function ($714) {

358+ return go(to($714));

359+ });

360+ return function ($713) {

361+ return PureScript_CST_Types.Guarded.create($712($713));

362+ };

363+ }

364+ };

365+};

366+var toFixityNameString = function () {

367+ return {

368+ toFixityName: function (str) {

369+ var v = PureScript_CST_Lexer.lexToken(str);

370+ if (v instanceof Data_Either.Right && v.value0 instanceof PureScript_CST_Types.TokLowerName) {

371+ return {

372+ module: v.value0.value0,

373+ name: new Data_Either.Left(v.value0.value1),

374+ token: Tidy_Codegen_Common.toSourceToken(v.value0)

375+ };

376+ };

377+ if (v instanceof Data_Either.Right && v.value0 instanceof PureScript_CST_Types.TokUpperName) {

378+ return {

379+ module: v.value0.value0,

380+ name: new Data_Either.Right(v.value0.value1),

381+ token: Tidy_Codegen_Common.toSourceToken(v.value0)

382+ };

383+ };

384+ return crashWith("Not a fixity name: " + str);

385+ }

386+ };

387+};

388+var overTrailingCommentsVoidL = {

389+ overTrailingComments: function (v) {

390+ return Data_Void.absurd;

391+ }

392+};

393+var overTrailingCommentsRecor = function (dictTypeEquals) {

394+ return {

395+ overTrailingComments: function (k) {

396+ return function (r) {

397+ var r$prime = coerce(r);

398+ return coerce((function () {

399+ var $429 = {};

400+ for (var $430 in r$prime) {

401+ if ({}.hasOwnProperty.call(r$prime, $430)) {

402+ $429[$430] = r$prime[$430];

403+ };

404+ };

405+ $429.trailingComments = k(r$prime.trailingComments);

406+ return $429;

407+ })());

408+ };

409+ }

410+ };

411+};

412+var overTrailingCommentsModul = {

413+ overTrailingComments: function (k) {

414+ return function (v) {

415+ return {

416+ decls: v.decls,

417+ end: v.end,

418+ trailingComments: k(v.trailingComments)

419+ };

420+ };

421+ }

422+};

423+var overLeadingCommentsVoid = {

424+ overLeadingComments: function (v) {

425+ return Data_Void.absurd;

426+ }

427+};

428+var overLeadingCommentsRecord = function (dictTypeEquals) {

429+ return {

430+ overLeadingComments: function (k) {

431+ return function (r) {

432+ var r$prime = coerce(r);

433+ return coerce((function () {

434+ var $434 = {};

435+ for (var $435 in r$prime) {

436+ if ({}.hasOwnProperty.call(r$prime, $435)) {

437+ $434[$435] = r$prime[$435];

438+ };

439+ };

440+ $434.leadingComments = k(r$prime.leadingComments);

441+ return $434;

442+ })());

443+ };

444+ }

445+ };

446+};

447+var fromTokenSymbolName = {

448+ fromToken: function (v) {

449+ if (v instanceof PureScript_CST_Types.TokSymbolName && v.value0 instanceof Data_Maybe.Nothing) {

450+ return new Data_Maybe.Just(v.value1);

451+ };

452+ if (v instanceof PureScript_CST_Types.TokOperator && v.value0 instanceof Data_Maybe.Nothing) {

453+ return new Data_Maybe.Just(v.value1);

454+ };

455+ return Data_Maybe.Nothing.value;

456+ }

457+};

458+var fromTokenRole = {

459+ fromToken: function (v) {

460+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "nominal")) {

461+ return new Data_Maybe.Just(PureScript_CST_Types.Nominal.value);

462+ };

463+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "representational")) {

464+ return new Data_Maybe.Just(PureScript_CST_Types.Representational.value);

465+ };

466+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "phantom")) {

467+ return new Data_Maybe.Just(PureScript_CST_Types.Phantom.value);

468+ };

469+ return Data_Maybe.Nothing.value;

470+ }

471+};

472+var fromTokenQualifiedSymbolN = {

473+ fromToken: function (v) {

474+ if (v instanceof PureScript_CST_Types.TokSymbolName) {

475+ return new Data_Maybe.Just(new Tidy_Codegen_Types.Qualified(v.value0, v.value1));

476+ };

477+ if (v instanceof PureScript_CST_Types.TokOperator) {

478+ return new Data_Maybe.Just(new Tidy_Codegen_Types.Qualified(v.value0, v.value1));

479+ };

480+ return Data_Maybe.Nothing.value;

481+ }

482+};

483+var fromTokenQualifiedProper = {

484+ fromToken: function (v) {

485+ if (v instanceof PureScript_CST_Types.TokUpperName) {

486+ return new Data_Maybe.Just(new Tidy_Codegen_Types.Qualified(v.value0, v.value1));

487+ };

488+ return Data_Maybe.Nothing.value;

489+ }

490+};

491+var fromTokenQualifiedOperato = {

492+ fromToken: function (v) {

493+ if (v instanceof PureScript_CST_Types.TokOperator) {

494+ return new Data_Maybe.Just(new Tidy_Codegen_Types.Qualified(v.value0, v.value1));

495+ };

496+ return Data_Maybe.Nothing.value;

497+ }

498+};

499+var fromTokenQualifiedIdent = {

500+ fromToken: function (v) {

501+ if (v instanceof PureScript_CST_Types.TokLowerName) {

502+ return new Data_Maybe.Just(new Tidy_Codegen_Types.Qualified(v.value0, v.value1));

503+ };

504+ return Data_Maybe.Nothing.value;

505+ }

506+};

507+var fromTokenProper = {

508+ fromToken: function (v) {

509+ if (v instanceof PureScript_CST_Types.TokUpperName && v.value0 instanceof Data_Maybe.Nothing) {

510+ return new Data_Maybe.Just(v.value1);

511+ };

512+ return Data_Maybe.Nothing.value;

513+ }

514+};

515+var fromTokenOperator = {

516+ fromToken: function (v) {

517+ if (v instanceof PureScript_CST_Types.TokOperator && v.value0 instanceof Data_Maybe.Nothing) {

518+ return new Data_Maybe.Just(v.value1);

519+ };

520+ return Data_Maybe.Nothing.value;

521+ }

522+};

523+var fromTokenNumber = {

524+ fromToken: function (v) {

525+ if (v instanceof PureScript_CST_Types.TokNumber) {

526+ return new Data_Maybe.Just(v.value1);

527+ };

528+ return Data_Maybe.Nothing.value;

529+ }

530+};

531+var fromTokenModuleName = {

532+ fromToken: function (v) {

533+ if (v instanceof PureScript_CST_Types.TokUpperName && v.value0 instanceof Data_Maybe.Just) {

534+ return new Data_Maybe.Just(unwrap(v.value0.value0) + ("." + v.value1));

535+ };

536+ if (v instanceof PureScript_CST_Types.TokUpperName && v.value0 instanceof Data_Maybe.Nothing) {

537+ return new Data_Maybe.Just(v.value1);

538+ };

539+ return Data_Maybe.Nothing.value;

540+ }

541+};

542+var fromTokenLabel = {

543+ fromToken: function (v) {

544+ if (v instanceof PureScript_CST_Types.TokLowerName && v.value0 instanceof Data_Maybe.Nothing) {

545+ return new Data_Maybe.Just(v.value1);

546+ };

547+ if (v instanceof PureScript_CST_Types.TokString) {

548+ return new Data_Maybe.Just(v.value1);

549+ };

550+ if (v instanceof PureScript_CST_Types.TokRawString) {

551+ return new Data_Maybe.Just(v.value0);

552+ };

553+ return Data_Maybe.Nothing.value;

554+ }

555+};

556+var fromTokenIntValue = {

557+ fromToken: function (v) {

558+ if (v instanceof PureScript_CST_Types.TokInt) {

559+ return new Data_Maybe.Just(v.value1);

560+ };

561+ return Data_Maybe.Nothing.value;

562+ }

563+};

564+var fromTokenIdent = {

565+ fromToken: function (v) {

566+ if (v instanceof PureScript_CST_Types.TokLowerName && v.value0 instanceof Data_Maybe.Nothing) {

567+ return new Data_Maybe.Just(v.value1);

568+ };

569+ return Data_Maybe.Nothing.value;

570+ }

571+};

572+var fromTokenFixity = {

573+ fromToken: function (v) {

574+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "infix")) {

575+ return new Data_Maybe.Just(PureScript_CST_Types.Infix.value);

576+ };

577+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "infixl")) {

578+ return new Data_Maybe.Just(PureScript_CST_Types.Infixr.value);

579+ };

580+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "infixr")) {

581+ return new Data_Maybe.Just(PureScript_CST_Types.Infixr.value);

582+ };

583+ return Data_Maybe.Nothing.value;

584+ }

585+};

586+var fromTokenBoolean = {

587+ fromToken: function (v) {

588+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "true")) {

589+ return new Data_Maybe.Just(true);

590+ };

591+ if (v instanceof PureScript_CST_Types.TokLowerName && (v.value0 instanceof Data_Maybe.Nothing && v.value1 === "false")) {

592+ return new Data_Maybe.Just(false);

593+ };

594+ return Data_Maybe.Nothing.value;

595+ }

596+};

597+var toWhere = function (dict) {

598+ return dict.toWhere;

599+};

600+var toWhere1 = /* #__PURE__ */ toWhere(toWhereExpr);

601+var toGuardedExpr = {

602+ toGuarded: function (tok) {

603+ var $715 = PureScript_CST_Types.Unconditional.create(tok);

604+ return function ($716) {

605+ return $715(toWhere1($716));

606+ };

607+ }

608+};

609+var toToken = function (dict) {

610+ return dict.toToken;

611+};

612+var toToken1 = /* #__PURE__ */ toToken(toTokenLabelLabel);

613+var toTokenStringLabel = {

614+ toToken: function (str) {

615+ var v = PureScript_CST_Lexer.lexToken(str);

616+ if (v instanceof Data_Either.Right && (v.value0 instanceof PureScript_CST_Types.TokLowerName && v.value0.value0 instanceof Data_Maybe.Nothing)) {

617+ return new Data_Tuple.Tuple(v.value0, v.value0.value1);

618+ };

619+ return toToken1(str);

620+ }

621+};

622+var toRecordLabeled = function (dict) {

623+ return dict.toRecordLabeled;

624+};

625+var toQualifiedName = function (dict) {

626+ return dict.toQualifiedName;

627+};

628+var toNonEmptyArray = function (dict) {

629+ return dict.toNonEmptyArray;

630+};

631+var toNonEmptyArray1 = /* #__PURE__ */ toNonEmptyArray(/* #__PURE__ */ toNonEmptyArrayArray());

632+var toName = function (dict) {

633+ return dict.toName;

634+};

635+var toRecordLabeledTuple = function (dictToName) {

636+ var toName2 = toName(dictToName);

637+ return function (dictTypeEquals) {

638+ var to = Type_Equality.to(dictTypeEquals);

639+ return {

640+ toRecordLabeled: function (v) {

641+ return new PureScript_CST_Types.RecordField(toName2(v.value0), Tidy_Codegen_Common.tokColon, to(v.value1));

642+ }

643+ };

644+ };

645+};

646+var toModuleName = function (dict) {

647+ return dict.toModuleName;

648+};

649+var toGuarded = function (dict) {

650+ return dict.toGuarded;

651+};

652+var toGuarded1 = /* #__PURE__ */ toGuarded(/* #__PURE__ */ toGuardedNonEmptyArray(Type_Equality.refl));

653+var toGuardedArray = function () {

654+ return function (dictTypeEquals) {

655+ var toGuarded2 = toGuarded(toGuardedNonEmptyArray(dictTypeEquals));

656+ return {

657+ toGuarded: function (tok) {

658+ var $717 = toGuarded2(tok);

659+ var $718 = toNonEmptyArray1("ToGuarded");

660+ return function ($719) {

661+ return $717($718($719));

662+ };

663+ }

664+ };

665+ };

666+};

667+var toGuardedGuardedBranch = {

668+ toGuarded: function (tok) {

669+ var $720 = toGuarded1(tok);

670+ return function ($721) {

671+ return $720(Data_Array_NonEmpty.singleton($721));

672+ };

673+ }

674+};

675+var toFixityName = function (dict) {

676+ return dict.toFixityName;

677+};

678+var overTrailingComments = function (dict) {

679+ return dict.overTrailingComments;

680+};

681+var overTrailingComments1 = /* #__PURE__ */ overTrailingComments(overTrailingCommentsModul);

682+var overTrailingCommentsModul1 = {

683+ overTrailingComments: function (k) {

684+ return function (v) {

685+ return {

686+ header: v.header,

687+ body: overTrailingComments1(k)(v.body)

688+ };

689+ };

690+ }

691+};

692+var overLeadingComments = function (dict) {

693+ return dict.overLeadingComments;

694+};

695+var overLeadingComments1 = /* #__PURE__ */ overLeadingComments(/* #__PURE__ */ overLeadingCommentsRecord(Type_Equality.refl));

696+var overLeadingCommentsImport = {

697+ overLeadingComments: function (k) {

698+ return function (v) {

699+ return {

700+ module: v.module,

701+ names: v.names,

702+ qualified: v.qualified,

703+ keyword: overLeadingComments1(k)(v.keyword)

704+ };

705+ };

706+ }

707+};

708+var overLeadingCommentsInstan = {

709+ overLeadingComments: function (k) {

710+ return function (v) {

711+ return {

712+ body: v.body,

713+ head: {

714+ name: v.head.name,

715+ constraints: v.head.constraints,

716+ className: v.head.className,

717+ types: v.head.types,

718+ keyword: overLeadingComments1(k)(v.head.keyword)

719+ }

720+ };

721+ };

722+ }

723+};

724+var overLeadingCommentsLabele = function (dictOverLeadingComments) {

725+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

726+ return {

727+ overLeadingComments: function (k) {

728+ return function (v) {

729+ return {

730+ separator: v.separator,

731+ value: v.value,

732+ label: overLeadingComments8(k)(v.label)

733+ };

734+ };

735+ }

736+ };

737+};

738+var overLeadingCommentsModule = {

739+ overLeadingComments: function (k) {

740+ return function (v) {

741+ return {

742+ name: v.name,

743+ exports: v.exports,

744+ where: v.where,

745+ imports: v.imports,

746+ keyword: overLeadingComments1(k)(v.keyword)

747+ };

748+ };

749+ }

750+};

751+var overLeadingComments2 = /* #__PURE__ */ overLeadingComments(overLeadingCommentsModule);

752+var overLeadingCommentsModule1 = {

753+ overLeadingComments: function (k) {

754+ return function (v) {

755+ return {

756+ body: v.body,

757+ header: overLeadingComments2(k)(v.header)

758+ };

759+ };

760+ }

761+};

762+var overLeadingCommentsName = {

763+ overLeadingComments: function (k) {

764+ return function (v) {

765+ return {

766+ name: v.name,

767+ token: overLeadingComments1(k)(v.token)

768+ };

769+ };

770+ }

771+};

772+var overLeadingComments3 = /* #__PURE__ */ overLeadingComments(/* #__PURE__ */ overLeadingCommentsLabele(overLeadingCommentsName));

773+var overLeadingComments4 = /* #__PURE__ */ overLeadingComments(overLeadingCommentsName);

774+var overLeadingCommentsQualif = {

775+ overLeadingComments: function (k) {

776+ return function (v) {

777+ return {

778+ module: v.module,

779+ name: v.name,

780+ token: overLeadingComments1(k)(v.token)

781+ };

782+ };

783+ }

784+};

785+var overLeadingComments5 = /* #__PURE__ */ overLeadingComments(overLeadingCommentsQualif);

786+var overLeadingCommentsSepara = function (dictOverLeadingComments) {

787+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

788+ return {

789+ overLeadingComments: function (k) {

790+ return function (v) {

791+ return {

792+ head: overLeadingComments8(k)(v.head),

793+ tail: v.tail

794+ };

795+ };

796+ }

797+ };

798+};

799+var overLeadingComments6 = /* #__PURE__ */ overLeadingComments(/* #__PURE__ */ overLeadingCommentsSepara(overLeadingCommentsInstan));

800+var overLeadingCommentsDeclar = function (dictOverLeadingComments) {

801+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

802+ return {

803+ overLeadingComments: function (k) {

804+ return function (v) {

805+ if (v instanceof PureScript_CST_Types.DeclData) {

806+ return new PureScript_CST_Types.DeclData({

807+ name: v.value0.name,

808+ vars: v.value0.vars,

809+ keyword: overLeadingComments1(k)(v.value0.keyword)

810+ }, v.value1);

811+ };

812+ if (v instanceof PureScript_CST_Types.DeclType) {

813+ return new PureScript_CST_Types.DeclType({

814+ name: v.value0.name,

815+ vars: v.value0.vars,

816+ keyword: overLeadingComments1(k)(v.value0.keyword)

817+ }, v.value1, v.value2);

818+ };

819+ if (v instanceof PureScript_CST_Types.DeclNewtype) {

820+ return new PureScript_CST_Types.DeclNewtype({

821+ name: v.value0.name,

822+ vars: v.value0.vars,

823+ keyword: overLeadingComments1(k)(v.value0.keyword)

824+ }, v.value1, v.value2, v.value3);

825+ };

826+ if (v instanceof PureScript_CST_Types.DeclClass) {

827+ return new PureScript_CST_Types.DeclClass({

828+ "super": v["value0"]["super"],

829+ name: v.value0.name,

830+ vars: v.value0.vars,

831+ fundeps: v.value0.fundeps,

832+ keyword: overLeadingComments1(k)(v.value0.keyword)

833+ }, v.value1);

834+ };

835+ if (v instanceof PureScript_CST_Types.DeclInstanceChain) {

836+ return new PureScript_CST_Types.DeclInstanceChain(overLeadingComments6(k)(v.value0));

837+ };

838+ if (v instanceof PureScript_CST_Types.DeclDerive) {

839+ return new PureScript_CST_Types.DeclDerive(overLeadingComments1(k)(v.value0), v.value1, v.value2);

840+ };

841+ if (v instanceof PureScript_CST_Types.DeclKindSignature) {

842+ return new PureScript_CST_Types.DeclKindSignature(overLeadingComments1(k)(v.value0), v.value1);

843+ };

844+ if (v instanceof PureScript_CST_Types.DeclSignature) {

845+ return new PureScript_CST_Types.DeclSignature(overLeadingComments3(k)(v.value0));

846+ };

847+ if (v instanceof PureScript_CST_Types.DeclValue) {

848+ return new PureScript_CST_Types.DeclValue({

849+ binders: v.value0.binders,

850+ guarded: v.value0.guarded,

851+ name: overLeadingComments4(k)(v.value0.name)

852+ });

853+ };

854+ if (v instanceof PureScript_CST_Types.DeclFixity) {

855+ return new PureScript_CST_Types.DeclFixity({

856+ prec: v.value0.prec,

857+ operator: v.value0.operator,

858+ keyword: lmap(overLeadingComments1(k))(v.value0.keyword)

859+ });

860+ };

861+ if (v instanceof PureScript_CST_Types.DeclForeign) {

862+ return new PureScript_CST_Types.DeclForeign(overLeadingComments1(k)(v.value0), v.value1, v.value2);

863+ };

864+ if (v instanceof PureScript_CST_Types.DeclRole) {

865+ return new PureScript_CST_Types.DeclRole(overLeadingComments1(k)(v.value0), v.value1, v.value2, v.value3);

866+ };

867+ if (v instanceof PureScript_CST_Types.DeclError) {

868+ return new PureScript_CST_Types.DeclError(overLeadingComments8(k)(v.value0));

869+ };

870+ throw new Error("Failed pattern match at Tidy.Codegen.Class (line 519, column 27 - line 532, column 55): " + [ v.constructor.name ]);

871+ };

872+ }

873+ };

874+};

875+var overLeadingCommentsTuple = function (dictOverLeadingComments) {

876+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

877+ return {

878+ overLeadingComments: function (k) {

879+ return function (v) {

880+ return new Data_Tuple.Tuple(overLeadingComments8(k)(v.value0), v.value1);

881+ };

882+ }

883+ };

884+};

885+var overLeadingCommentsWrappe = {

886+ overLeadingComments: function (k) {

887+ return function (v) {

888+ return {

889+ value: v.value,

890+ close: v.close,

891+ open: overLeadingComments1(k)(v.open)

892+ };

893+ };

894+ }

895+};

896+var overLeadingComments7 = /* #__PURE__ */ overLeadingComments(overLeadingCommentsWrappe);

897+var overLeadingCommentsBinder = function (dictOverLeadingComments) {

898+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

899+ return {

900+ overLeadingComments: function (k) {

901+ return function (v) {

902+ if (v instanceof PureScript_CST_Types.BinderWildcard) {

903+ return new PureScript_CST_Types.BinderWildcard(overLeadingComments1(k)(v.value0));

904+ };

905+ if (v instanceof PureScript_CST_Types.BinderVar) {

906+ return new PureScript_CST_Types.BinderVar(overLeadingComments4(k)(v.value0));

907+ };

908+ if (v instanceof PureScript_CST_Types.BinderNamed) {

909+ return new PureScript_CST_Types.BinderNamed(overLeadingComments4(k)(v.value0), v.value1, v.value2);

910+ };

911+ if (v instanceof PureScript_CST_Types.BinderConstructor) {

912+ return new PureScript_CST_Types.BinderConstructor(overLeadingComments5(k)(v.value0), v.value1);

913+ };

914+ if (v instanceof PureScript_CST_Types.BinderBoolean) {

915+ return new PureScript_CST_Types.BinderBoolean(overLeadingComments1(k)(v.value0), v.value1);

916+ };

917+ if (v instanceof PureScript_CST_Types.BinderChar) {

918+ return new PureScript_CST_Types.BinderChar(overLeadingComments1(k)(v.value0), v.value1);

919+ };

920+ if (v instanceof PureScript_CST_Types.BinderString) {

921+ return new PureScript_CST_Types.BinderString(overLeadingComments1(k)(v.value0), v.value1);

922+ };

923+ if (v instanceof PureScript_CST_Types.BinderInt && v.value0 instanceof Data_Maybe.Just) {

924+ return new PureScript_CST_Types.BinderInt(new Data_Maybe.Just(overLeadingComments1(k)(v.value0.value0)), v.value1, v.value2);

925+ };

926+ if (v instanceof PureScript_CST_Types.BinderInt) {

927+ return new PureScript_CST_Types.BinderInt(Data_Maybe.Nothing.value, overLeadingComments1(k)(v.value1), v.value2);

928+ };

929+ if (v instanceof PureScript_CST_Types.BinderNumber && v.value0 instanceof Data_Maybe.Just) {

930+ return new PureScript_CST_Types.BinderNumber(new Data_Maybe.Just(overLeadingComments1(k)(v.value0.value0)), v.value1, v.value2);

931+ };

932+ if (v instanceof PureScript_CST_Types.BinderNumber) {

933+ return new PureScript_CST_Types.BinderNumber(Data_Maybe.Nothing.value, overLeadingComments1(k)(v.value1), v.value2);

934+ };

935+ if (v instanceof PureScript_CST_Types.BinderArray) {

936+ return new PureScript_CST_Types.BinderArray(overLeadingComments7(k)(v.value0));

937+ };

938+ if (v instanceof PureScript_CST_Types.BinderRecord) {

939+ return new PureScript_CST_Types.BinderRecord(overLeadingComments7(k)(v.value0));

940+ };

941+ if (v instanceof PureScript_CST_Types.BinderParens) {

942+ return new PureScript_CST_Types.BinderParens(overLeadingComments7(k)(v.value0));

943+ };

944+ if (v instanceof PureScript_CST_Types.BinderTyped) {

945+ return new PureScript_CST_Types.BinderTyped(overLeadingComments(overLeadingCommentsBinder(dictOverLeadingComments))(k)(v.value0), v.value1, v.value2);

946+ };

947+ if (v instanceof PureScript_CST_Types.BinderOp) {

948+ return new PureScript_CST_Types.BinderOp(overLeadingComments(overLeadingCommentsBinder(dictOverLeadingComments))(k)(v.value0), v.value1);

949+ };

950+ if (v instanceof PureScript_CST_Types.BinderError) {

951+ return new PureScript_CST_Types.BinderError(overLeadingComments8(k)(v.value0));

952+ };

953+ throw new Error("Failed pattern match at Tidy.Codegen.Class (line 590, column 27 - line 607, column 59): " + [ v.constructor.name ]);

954+ };

955+ }

956+ };

957+};

958+var overLeadingCommentsExpr = function (dictOverLeadingComments) {

959+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

960+ return {

961+ overLeadingComments: function (k) {

962+ return function (v) {

963+ if (v instanceof PureScript_CST_Types.ExprHole) {

964+ return new PureScript_CST_Types.ExprHole(overLeadingComments4(k)(v.value0));

965+ };

966+ if (v instanceof PureScript_CST_Types.ExprSection) {

967+ return new PureScript_CST_Types.ExprSection(overLeadingComments1(k)(v.value0));

968+ };

969+ if (v instanceof PureScript_CST_Types.ExprIdent) {

970+ return new PureScript_CST_Types.ExprIdent(overLeadingComments5(k)(v.value0));

971+ };

972+ if (v instanceof PureScript_CST_Types.ExprConstructor) {

973+ return new PureScript_CST_Types.ExprConstructor(overLeadingComments5(k)(v.value0));

974+ };

975+ if (v instanceof PureScript_CST_Types.ExprBoolean) {

976+ return new PureScript_CST_Types.ExprBoolean(overLeadingComments1(k)(v.value0), v.value1);

977+ };

978+ if (v instanceof PureScript_CST_Types.ExprChar) {

979+ return new PureScript_CST_Types.ExprChar(overLeadingComments1(k)(v.value0), v.value1);

980+ };

981+ if (v instanceof PureScript_CST_Types.ExprString) {

982+ return new PureScript_CST_Types.ExprString(overLeadingComments1(k)(v.value0), v.value1);

983+ };

984+ if (v instanceof PureScript_CST_Types.ExprInt) {

985+ return new PureScript_CST_Types.ExprInt(overLeadingComments1(k)(v.value0), v.value1);

986+ };

987+ if (v instanceof PureScript_CST_Types.ExprNumber) {

988+ return new PureScript_CST_Types.ExprNumber(overLeadingComments1(k)(v.value0), v.value1);

989+ };

990+ if (v instanceof PureScript_CST_Types.ExprArray) {

991+ return new PureScript_CST_Types.ExprArray(overLeadingComments7(k)(v.value0));

992+ };

993+ if (v instanceof PureScript_CST_Types.ExprRecord) {

994+ return new PureScript_CST_Types.ExprRecord(overLeadingComments7(k)(v.value0));

995+ };

996+ if (v instanceof PureScript_CST_Types.ExprParens) {

997+ return new PureScript_CST_Types.ExprParens(overLeadingComments7(k)(v.value0));

998+ };

999+ if (v instanceof PureScript_CST_Types.ExprTyped) {

1000+ return new PureScript_CST_Types.ExprTyped(overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0), v.value1, v.value2);

1001+ };

1002+ if (v instanceof PureScript_CST_Types.ExprInfix) {

1003+ return new PureScript_CST_Types.ExprInfix(overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0), v.value1);

1004+ };

1005+ if (v instanceof PureScript_CST_Types.ExprOp) {

1006+ return new PureScript_CST_Types.ExprOp(overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0), v.value1);

1007+ };

1008+ if (v instanceof PureScript_CST_Types.ExprOpName) {

1009+ return new PureScript_CST_Types.ExprOpName(overLeadingComments5(k)(v.value0));

1010+ };

1011+ if (v instanceof PureScript_CST_Types.ExprNegate) {

1012+ return new PureScript_CST_Types.ExprNegate(overLeadingComments1(k)(v.value0), v.value1);

1013+ };

1014+ if (v instanceof PureScript_CST_Types.ExprRecordAccessor) {

1015+ return new PureScript_CST_Types.ExprRecordAccessor({

1016+ dot: v.value0.dot,

1017+ path: v.value0.path,

1018+ expr: overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0.expr)

1019+ });

1020+ };

1021+ if (v instanceof PureScript_CST_Types.ExprRecordUpdate) {

1022+ return new PureScript_CST_Types.ExprRecordUpdate(overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0), v.value1);

1023+ };

1024+ if (v instanceof PureScript_CST_Types.ExprApp) {

1025+ return new PureScript_CST_Types.ExprApp(overLeadingComments(overLeadingCommentsExpr(dictOverLeadingComments))(k)(v.value0), v.value1);

1026+ };

1027+ if (v instanceof PureScript_CST_Types.ExprLambda) {

1028+ return new PureScript_CST_Types.ExprLambda({

1029+ binders: v.value0.binders,

1030+ arrow: v.value0.arrow,

1031+ body: v.value0.body,

1032+ symbol: overLeadingComments1(k)(v.value0.symbol)

1033+ });

1034+ };

1035+ if (v instanceof PureScript_CST_Types.ExprIf) {

1036+ return new PureScript_CST_Types.ExprIf({

1037+ cond: v.value0.cond,

1038+ then: v.value0.then,

1039+ "true": v["value0"]["true"],

1040+ "else": v["value0"]["else"],

1041+ "false": v["value0"]["false"],

1042+ keyword: overLeadingComments1(k)(v.value0.keyword)

1043+ });

1044+ };

1045+ if (v instanceof PureScript_CST_Types.ExprCase) {

1046+ return new PureScript_CST_Types.ExprCase({

1047+ head: v.value0.head,

1048+ of: v.value0.of,

1049+ branches: v.value0.branches,

1050+ keyword: overLeadingComments1(k)(v.value0.keyword)

1051+ });

1052+ };

1053+ if (v instanceof PureScript_CST_Types.ExprLet) {

1054+ return new PureScript_CST_Types.ExprLet({

1055+ bindings: v.value0.bindings,

1056+ "in": v["value0"]["in"],

1057+ body: v.value0.body,

1058+ keyword: overLeadingComments1(k)(v.value0.keyword)

1059+ });

1060+ };

1061+ if (v instanceof PureScript_CST_Types.ExprDo) {

1062+ return new PureScript_CST_Types.ExprDo({

1063+ statements: v.value0.statements,

1064+ keyword: overLeadingComments1(k)(v.value0.keyword)

1065+ });

1066+ };

1067+ if (v instanceof PureScript_CST_Types.ExprAdo) {

1068+ return new PureScript_CST_Types.ExprAdo({

1069+ statements: v.value0.statements,

1070+ "in": v["value0"]["in"],

1071+ result: v.value0.result,

1072+ keyword: overLeadingComments1(k)(v.value0.keyword)

1073+ });

1074+ };

1075+ if (v instanceof PureScript_CST_Types.ExprError) {

1076+ return new PureScript_CST_Types.ExprError(overLeadingComments8(k)(v.value0));

1077+ };

1078+ throw new Error("Failed pattern match at Tidy.Codegen.Class (line 560, column 27 - line 587, column 55): " + [ v.constructor.name ]);

1079+ };

1080+ }

1081+ };

1082+};

1083+var overLeadingCommentsType = function (dictOverLeadingComments) {

1084+ var overLeadingComments8 = overLeadingComments(dictOverLeadingComments);

1085+ return {

1086+ overLeadingComments: function (k) {

1087+ return function (v) {

1088+ if (v instanceof PureScript_CST_Types.TypeVar) {

1089+ return new PureScript_CST_Types.TypeVar(overLeadingComments4(k)(v.value0));

1090+ };

1091+ if (v instanceof PureScript_CST_Types.TypeConstructor) {

1092+ return new PureScript_CST_Types.TypeConstructor(overLeadingComments5(k)(v.value0));

1093+ };

1094+ if (v instanceof PureScript_CST_Types.TypeWildcard) {

1095+ return new PureScript_CST_Types.TypeWildcard(overLeadingComments1(k)(v.value0));

1096+ };

1097+ if (v instanceof PureScript_CST_Types.TypeHole) {

1098+ return new PureScript_CST_Types.TypeHole(overLeadingComments4(k)(v.value0));

1099+ };

1100+ if (v instanceof PureScript_CST_Types.TypeString) {

1101+ return new PureScript_CST_Types.TypeString(overLeadingComments1(k)(v.value0), v.value1);

1102+ };

1103+ if (v instanceof PureScript_CST_Types.TypeInt && v.value0 instanceof Data_Maybe.Just) {

1104+ return new PureScript_CST_Types.TypeInt(new Data_Maybe.Just(overLeadingComments1(k)(v.value0.value0)), v.value1, v.value2);

1105+ };

1106+ if (v instanceof PureScript_CST_Types.TypeInt) {

1107+ return new PureScript_CST_Types.TypeInt(Data_Maybe.Nothing.value, overLeadingComments1(k)(v.value1), v.value2);

1108+ };

1109+ if (v instanceof PureScript_CST_Types.TypeRow) {

1110+ return new PureScript_CST_Types.TypeRow(overLeadingComments7(k)(v.value0));

1111+ };

1112+ if (v instanceof PureScript_CST_Types.TypeRecord) {

1113+ return new PureScript_CST_Types.TypeRecord(overLeadingComments7(k)(v.value0));

1114+ };

1115+ if (v instanceof PureScript_CST_Types.TypeForall) {

1116+ return new PureScript_CST_Types.TypeForall(overLeadingComments1(k)(v.value0), v.value1, v.value2, v.value3);

1117+ };

1118+ if (v instanceof PureScript_CST_Types.TypeKinded) {

1119+ return new PureScript_CST_Types.TypeKinded(overLeadingComments(overLeadingCommentsType(dictOverLeadingComments))(k)(v.value0), v.value1, v.value2);

1120+ };

1121+ if (v instanceof PureScript_CST_Types.TypeApp) {

1122+ return new PureScript_CST_Types.TypeApp(overLeadingComments(overLeadingCommentsType(dictOverLeadingComments))(k)(v.value0), v.value1);

1123+ };

1124+ if (v instanceof PureScript_CST_Types.TypeOp) {

1125+ return new PureScript_CST_Types.TypeOp(overLeadingComments(overLeadingCommentsType(dictOverLeadingComments))(k)(v.value0), v.value1);

1126+ };

1127+ if (v instanceof PureScript_CST_Types.TypeOpName) {

1128+ return new PureScript_CST_Types.TypeOpName(overLeadingComments5(k)(v.value0));

1129+ };

1130+ if (v instanceof PureScript_CST_Types.TypeArrow) {

1131+ return new PureScript_CST_Types.TypeArrow(overLeadingComments(overLeadingCommentsType(dictOverLeadingComments))(k)(v.value0), v.value1, v.value2);

1132+ };

1133+ if (v instanceof PureScript_CST_Types.TypeArrowName) {

1134+ return new PureScript_CST_Types.TypeArrowName(overLeadingComments1(k)(v.value0));

1135+ };

1136+ if (v instanceof PureScript_CST_Types.TypeConstrained) {

1137+ return new PureScript_CST_Types.TypeConstrained(overLeadingComments(overLeadingCommentsType(dictOverLeadingComments))(k)(v.value0), v.value1, v.value2);

1138+ };

1139+ if (v instanceof PureScript_CST_Types.TypeParens) {

1140+ return new PureScript_CST_Types.TypeParens(overLeadingComments7(k)(v.value0));

1141+ };

1142+ if (v instanceof PureScript_CST_Types["TypeError"]) {

1143+ return new PureScript_CST_Types["TypeError"](overLeadingComments8(k)(v.value0));

1144+ };

1145+ throw new Error("Failed pattern match at Tidy.Codegen.Class (line 538, column 27 - line 557, column 55): " + [ v.constructor.name ]);

1146+ };

1147+ }

1148+ };

1149+};

1150+var fromToken = function (dict) {

1151+ return dict.fromToken;

1152+};

1153+var toTokenFromString = function () {

1154+ return function (dictFromToken) {

1155+ var fromToken1 = fromToken(dictFromToken);

1156+ return function (v) {

1157+ return function (str) {

1158+ var v1 = PureScript_CST_Lexer.lexToken(str);

1159+ var v2 = function (v3) {

1160+ return crashWith(v + (": " + str));

1161+ };

1162+ if (v1 instanceof Data_Either.Right) {

1163+ var $693 = fromToken1(v1.value0);

1164+ if ($693 instanceof Data_Maybe.Just) {

1165+ return new Data_Tuple.Tuple(v1.value0, $693.value0);

1166+ };

1167+ return v2(true);

1168+ };

1169+ return v2(true);

1170+ };

1171+ };

1172+ };

1173+};

1174+var toTokenFromString1 = /* #__PURE__ */ toTokenFromString();

1175+var toTokenFromString2 = /* #__PURE__ */ toTokenFromString1(fromTokenIdent);

1176+var toTokenFromString3 = /* #__PURE__ */ toTokenFromString1(fromTokenModuleName);

1177+var toTokenFromString4 = /* #__PURE__ */ toTokenFromString1(fromTokenOperator);

1178+var toTokenFromString5 = /* #__PURE__ */ toTokenFromString1(fromTokenProper);

1179+var toTokenFromString6 = /* #__PURE__ */ toTokenFromString1(fromTokenQualifiedIdent);

1180+var toTokenFromString7 = /* #__PURE__ */ toTokenFromString1(fromTokenQualifiedOperato);

1181+var toTokenFromString8 = /* #__PURE__ */ toTokenFromString1(fromTokenQualifiedProper);

1182+var toTokenFromString9 = /* #__PURE__ */ toTokenFromString1(fromTokenQualifiedSymbolN);

1183+var toQualified = function () {

1184+ return function (dictFromToken) {

1185+ var $722 = toTokenFromString1(dictFromToken)("Not Qualified");

1186+ return function ($723) {

1187+ return Data_Tuple.snd($722($723));

1188+ };

1189+ };

1190+};

1191+var toTokenStringIdent = function () {

1192+ return {

1193+ toToken: toTokenFromString2("Not an Ident")

1194+ };

1195+};

1196+var toTokenStringModuleName = function () {

1197+ return {

1198+ toToken: toTokenFromString3("Not a ModuleName")

1199+ };

1200+};

1201+var toTokenStringModuleName1 = /* #__PURE__ */ toTokenStringModuleName();

1202+var toToken2 = /* #__PURE__ */ toToken(toTokenStringModuleName1);

1203+var toModuleNameString = function () {

1204+ return {

1205+ toModuleName: function ($724) {

1206+ return Data_Tuple.snd(toToken2($724));

1207+ }

1208+ };

1209+};

1210+var toTokenStringOperator = function () {

1211+ return {

1212+ toToken: toTokenFromString4("Not an Operator")

1213+ };

1214+};

1215+var toTokenStringProper = function () {

1216+ return {

1217+ toToken: toTokenFromString5("Not a Proper")

1218+ };

1219+};

1220+var toTokenStringQualifiedIde = function () {

1221+ return {

1222+ toToken: toTokenFromString6("Not a Qualified dIdent")

1223+ };

1224+};

1225+var toTokenStringQualifiedOpe = function () {

1226+ return {

1227+ toToken: toTokenFromString7("Not a Qualified Operator")

1228+ };

1229+};

1230+var toTokenStringQualifiedPro = function () {

1231+ return {

1232+ toToken: toTokenFromString8("Not a Qualified Proper")

1233+ };

1234+};

1235+var toTokenStringQualifiedSym = function () {

1236+ return {

1237+ toToken: toTokenFromString9("Not a Qualified SymbolName")

1238+ };

1239+};

1240+var toQualifiedNameString = function () {

1241+ return function (dictFromToken) {

1242+ var fromToken1 = fromToken(dictFromToken);

1243+ return {

1244+ toQualifiedName: function (str) {

1245+ var v = PureScript_CST_Lexer.lexToken(str);

1246+ var v1 = function (v2) {

1247+ return crashWith("Not a QualifiedName: " + str);

1248+ };

1249+ if (v instanceof Data_Either.Right) {

1250+ var $697 = fromToken1(v.value0);

1251+ if ($697 instanceof Data_Maybe.Just) {

1252+ return {

1253+ module: $697.value0.value0,

1254+ name: $697.value0.value1,

1255+ token: Tidy_Codegen_Common.toSourceToken(v.value0)

1256+ };

1257+ };

1258+ return v1(true);

1259+ };

1260+ return v1(true);

1261+ }

1262+ };

1263+ };

1264+};

1265+var defaultToQualifiedName = function (dictToToken) {

1266+ var toToken3 = toToken(dictToToken);

1267+ return function (v) {

1268+ var v1 = toToken3(v.value1);

1269+ return {

1270+ module: v.value0,

1271+ name: v1.value1,

1272+ token: Tidy_Codegen_Common.toSourceToken(v1.value0)

1273+ };

1274+ };

1275+};

1276+var toQualifiedNameQualified = function (dictToToken) {

1277+ return {

1278+ toQualifiedName: defaultToQualifiedName(dictToToken)

1279+ };

1280+};

1281+var toQualifiedNameIdentIdent = {

1282+ toQualifiedName: /* #__PURE__ */ (function () {

1283+ var $725 = toQualifiedName(toQualifiedNameQualified(toTokenIdentIdent));

1284+ var $726 = Tidy_Codegen_Types.Qualified.create(Data_Maybe.Nothing.value);

1285+ return function ($727) {

1286+ return $725($726($727));

1287+ };

1288+ })()

1289+};

1290+var toFixityNameIdent = {

1291+ toFixityName: /* #__PURE__ */ (function () {

1292+ var $728 = over(PureScript_CST_Types.QualifiedName)(function (a) {

1293+ return {

1294+ module: a.module,

1295+ token: a.token,

1296+ name: new Data_Either.Left(a.name)

1297+ };

1298+ });

1299+ var $729 = toQualifiedName(toQualifiedNameIdentIdent);

1300+ return function ($730) {

1301+ return $728($729($730));

1302+ };

1303+ })()

1304+};

1305+var toQualifiedNameOperatorOp = {

1306+ toQualifiedName: /* #__PURE__ */ (function () {

1307+ var $731 = toQualifiedName(toQualifiedNameQualified(toTokenOperatorOperator));

1308+ var $732 = Tidy_Codegen_Types.Qualified.create(Data_Maybe.Nothing.value);

1309+ return function ($733) {

1310+ return $731($732($733));

1311+ };

1312+ })()

1313+};

1314+var toQualifiedNameProperProp = {

1315+ toQualifiedName: /* #__PURE__ */ (function () {

1316+ var $734 = toQualifiedName(toQualifiedNameQualified(toTokenProperProper));

1317+ var $735 = Tidy_Codegen_Types.Qualified.create(Data_Maybe.Nothing.value);

1318+ return function ($736) {

1319+ return $734($735($736));

1320+ };

1321+ })()

1322+};

1323+var toFixityNameProper = {

1324+ toFixityName: /* #__PURE__ */ (function () {

1325+ var $737 = over(PureScript_CST_Types.QualifiedName)(function (a) {

1326+ return {

1327+ module: a.module,

1328+ token: a.token,

1329+ name: new Data_Either.Right(a.name)

1330+ };

1331+ });

1332+ var $738 = toQualifiedName(toQualifiedNameProperProp);

1333+ return function ($739) {

1334+ return $737($738($739));

1335+ };

1336+ })()

1337+};

1338+var toQualifiedNameSymbolName = {

1339+ toQualifiedName: /* #__PURE__ */ (function () {

1340+ var $740 = toQualifiedName(toQualifiedNameQualified(toTokenSymbolNameOperator));

1341+ var $741 = Tidy_Codegen_Types.Qualified.create(Data_Maybe.Nothing.value);

1342+ return function ($742) {

1343+ return $740($741($742));

1344+ };

1345+ })()

1346+};

1347+var defaultToName = function (dictToToken) {

1348+ var toToken3 = toToken(dictToToken);

1349+ return function (val) {

1350+ var v = toToken3(val);

1351+ return {

1352+ name: v.value1,

1353+ token: Tidy_Codegen_Common.toSourceToken(v.value0)

1354+ };

1355+ };

1356+};

1357+var defaultToName1 = /* #__PURE__ */ defaultToName(/* #__PURE__ */ toTokenStringIdent());

1358+var defaultToName2 = /* #__PURE__ */ defaultToName(toTokenStringModuleName1);

1359+var defaultToName3 = /* #__PURE__ */ defaultToName(/* #__PURE__ */ toTokenStringOperator());

1360+var defaultToName4 = /* #__PURE__ */ defaultToName(/* #__PURE__ */ toTokenStringProper());

1361+var defaultToName5 = /* #__PURE__ */ defaultToName(/* #__PURE__ */ toTokenStringSymbolName());

1362+var toNameIdentIdent = {

1363+ toName: /* #__PURE__ */ defaultToName(toTokenIdentIdent)

1364+};

1365+var toRecordLabeledIdent = {

1366+ toRecordLabeled: /* #__PURE__ */ (function () {

1367+ var $743 = toName(toNameIdentIdent);

1368+ return function ($744) {

1369+ return PureScript_CST_Types.RecordPun.create($743($744));

1370+ };

1371+ })()

1372+};

1373+var toNameLabelLabel = {

1374+ toName: /* #__PURE__ */ defaultToName(toTokenLabelLabel)

1375+};

1376+var toNameModuleNameModuleNam = {

1377+ toName: /* #__PURE__ */ defaultToName(toTokenModuleNameModuleNa)

1378+};

1379+var toNameOperatorOperator = {

1380+ toName: /* #__PURE__ */ defaultToName(toTokenOperatorOperator)

1381+};

1382+var toNameProperProper = {

1383+ toName: /* #__PURE__ */ defaultToName(toTokenProperProper)

1384+};

1385+var toNameStringIdent = function () {

1386+ return {

1387+ toName: defaultToName1

1388+ };

1389+};

1390+var toName1 = /* #__PURE__ */ toName(/* #__PURE__ */ toNameStringIdent());

1391+var toRecordLabeledString = function () {

1392+ return {

1393+ toRecordLabeled: function ($745) {

1394+ return PureScript_CST_Types.RecordPun.create(toName1($745));

1395+ }

1396+ };

1397+};

1398+var toNameStringLabel = {

1399+ toName: /* #__PURE__ */ defaultToName(toTokenStringLabel)

1400+};

1401+var toNameStringModuleName = function () {

1402+ return {

1403+ toName: defaultToName2

1404+ };

1405+};

1406+var toNameStringOperator = function () {

1407+ return {

1408+ toName: defaultToName3

1409+ };

1410+};

1411+var toNameStringProper = function () {

1412+ return {

1413+ toName: defaultToName4

1414+ };

1415+};

1416+var toNameStringSymbolName = function () {

1417+ return {

1418+ toName: defaultToName5

1419+ };

1420+};

1421+var toNameSymbolNameSymbolNam = {

1422+ toName: /* #__PURE__ */ defaultToName(toTokenSymbolNameSymbolNa)

1423+};

1424+export {

1425+ fromToken,

1426+ overLeadingComments,

1427+ overTrailingComments,

1428+ toFixityName,

1429+ toGuarded,

1430+ toModuleName,

1431+ toName,

1432+ toNonEmptyArray,

1433+ toQualifiedName,

1434+ toRecordLabeled,

1435+ toToken,

1436+ toWhere,

1437+ ErrorPrefix,

1438+ toTokenFromString,

1439+ defaultToName,

1440+ toQualified,

1441+ defaultToQualifiedName,

1442+ toNonEmptyArrayArray,

1443+ toNonEmptyArrayNonEmptyAr,

1444+ toTokenStringIdent,

1445+ toTokenNameIdentIdent,

1446+ toTokenIdentIdent,

1447+ toTokenStringProper,

1448+ toTokenNameProperProper,

1449+ toTokenProperProper,

1450+ toTokenStringOperator,

1451+ toTokenNameOperatorOperat,

1452+ toTokenOperatorOperator,

1453+ toTokenStringSymbolName,

1454+ toTokenNameSymbolNameSymb,

1455+ toTokenSymbolNameSymbolNa,

1456+ toTokenSymbolNameOperator,

1457+ toTokenStringModuleName,

1458+ toTokenNameModuleNameModu,

1459+ toTokenModuleNameModuleNa,

1460+ toTokenStringLabel,

1461+ toTokenNameLabelLabel,

1462+ toTokenLabelLabel,

1463+ toTokenIntIntValue,

1464+ toTokenIntInt,

1465+ toTokenNumberNumber,

1466+ toTokenStringString,

1467+ toTokenBooleanBoolean,

1468+ toTokenFixityFixity,

1469+ toTokenRoleRole,

1470+ toTokenStringQualifiedIde,

1471+ toTokenNameIdentQualified,

1472+ toTokenQualifiedIdentQual,

1473+ toTokenStringQualifiedPro,

1474+ toTokenNameProperQualifie,

1475+ toTokenQualifiedProperQua,

1476+ toTokenStringQualifiedOpe,

1477+ toTokenNameOperatorQualif,

1478+ toTokenQualifiedOperatorQ,

1479+ toTokenStringQualifiedSym,

1480+ toTokenNameSymbolNameQual,

1481+ toTokenQualifiedSymbolNam,

1482+ toTokenQualifiedNameQuali,

1483+ toNameStringIdent,

1484+ toNameIdentIdent,

1485+ toNameNameIdentIdent,

1486+ toNameStringProper,

1487+ toNameProperProper,

1488+ toNameNameProperProper,

1489+ toNameStringOperator,

1490+ toNameOperatorOperator,

1491+ toNameNameOperatorOperato,

1492+ toNameStringSymbolName,

1493+ toNameSymbolNameSymbolNam,

1494+ toNameOperatorSymbolName,

1495+ toNameNameOperatorSymbolN,

1496+ toNameStringLabel,

1497+ toNameLabelLabel,

1498+ toNameStringModuleName,

1499+ toNameModuleNameModuleNam,

1500+ toNameQualifiedName,

1501+ fromTokenIdent,

1502+ fromTokenQualifiedIdent,

1503+ fromTokenProper,

1504+ fromTokenQualifiedProper,

1505+ fromTokenOperator,

1506+ fromTokenQualifiedOperato,

1507+ fromTokenSymbolName,

1508+ fromTokenQualifiedSymbolN,

1509+ fromTokenModuleName,

1510+ fromTokenLabel,

1511+ fromTokenIntValue,

1512+ fromTokenNumber,

1513+ fromTokenBoolean,

1514+ fromTokenFixity,

1515+ fromTokenRole,

1516+ toQualifiedNameString,

1517+ toQualifiedNameQualified,

1518+ toQualifiedNameIdentIdent,

1519+ toQualifiedNameProperProp,

1520+ toQualifiedNameOperatorOp,

1521+ toQualifiedNameSymbolName,

1522+ toQualifiedNameName,

1523+ toQualifiedNameQualifiedN2,

1524+ toQualifiedNameQualifiedN1,

1525+ toQualifiedNameQualifiedN,

1526+ toModuleNameString,

1527+ toModuleNameModuleName,

1528+ toRecordLabeledString,

1529+ toRecordLabeledIdent,

1530+ toRecordLabeledNameIdent,

1531+ toRecordLabeledTuple,

1532+ toRecordLabeledRecordLabe,

1533+ toWhereExpr,

1534+ toWhereWhere,

1535+ toGuardedExpr,

1536+ toGuardedWhere,

1537+ toGuardedGuardedBranch,

1538+ toGuardedNonEmptyArray,

1539+ toGuardedArray,

1540+ toFixityNameString,

1541+ toFixityNameIdent,

1542+ toFixityNameProper,

1543+ overLeadingCommentsVoid,

1544+ overTrailingCommentsVoidL,

1545+ overLeadingCommentsRecord,

1546+ overTrailingCommentsRecor,

1547+ overLeadingCommentsModule,

1548+ overTrailingCommentsModul,

1549+ overLeadingCommentsModule1,

1550+ overTrailingCommentsModul1,

1551+ overLeadingCommentsImport,

1552+ overLeadingCommentsDeclar,

1553+ overLeadingCommentsInstan,

1554+ overLeadingCommentsType,

1555+ overLeadingCommentsExpr,

1556+ overLeadingCommentsBinder,

1557+ overLeadingCommentsName,

1558+ overLeadingCommentsQualif,

1559+ overLeadingCommentsLabele,

1560+ overLeadingCommentsSepara,

1561+ overLeadingCommentsWrappe,

1562+ overLeadingCommentsTuple

1563+};

output-compile-fail/Tidy.Codegen.Common/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.Common/index.jsnew file+286

@@ -0,0 +1,286 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

3+import * as Data_Functor from "../Data.Functor/index.js";

4+import * as Data_Maybe from "../Data.Maybe/index.js";

5+import * as Data_Semiring from "../Data.Semiring/index.js";

6+import * as Data_Tuple from "../Data.Tuple/index.js";

7+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

8+var semiringRecord = /* #__PURE__ */ Data_Semiring.semiringRecord();

9+var semiringRecord1 = /* #__PURE__ */ semiringRecord(/* #__PURE__ */ Data_Semiring.semiringRecordCons({

10+ reflectSymbol: function () {

11+ return "column";

12+ }

13+})()(/* #__PURE__ */ Data_Semiring.semiringRecordCons({

14+ reflectSymbol: function () {

15+ return "line";

16+ }

17+})()(Data_Semiring.semiringRecordNil)(Data_Semiring.semiringInt))(Data_Semiring.semiringInt));

18+var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorArray);

19+var map1 = /* #__PURE__ */ Data_Functor.map(Data_Maybe.functorMaybe);

20+var zeroRange = /* #__PURE__ */ Data_Semiring.zero(/* #__PURE__ */ semiringRecord(/* #__PURE__ */ Data_Semiring.semiringRecordCons({

21+ reflectSymbol: function () {

22+ return "end";

23+ }

24+})()(/* #__PURE__ */ Data_Semiring.semiringRecordCons({

25+ reflectSymbol: function () {

26+ return "start";

27+ }

28+})()(Data_Semiring.semiringRecordNil)(semiringRecord1))(semiringRecord1)));

29+var toWrapped = function (open) {

30+ return function (close) {

31+ return function ($35) {

32+ return PureScript_CST_Types.Wrapped((function (v) {

33+ return {

34+ open: open,

35+ close: close,

36+ value: v

37+ };

38+ })($35));

39+ };

40+ };

41+};

42+var toSourceToken = function (v) {

43+ return {

44+ range: zeroRange,

45+ leadingComments: [ ],

46+ trailingComments: [ ],

47+ value: v

48+ };

49+};

50+var tokAll = /* #__PURE__ */ (function () {

51+ return toSourceToken(new PureScript_CST_Types.TokSymbolName(Data_Maybe.Nothing.value, ".."));

52+})();

53+var tokAt = /* #__PURE__ */ (function () {

54+ return toSourceToken(PureScript_CST_Types.TokAt.value);

55+})();

56+var tokBackslash = /* #__PURE__ */ (function () {

57+ return toSourceToken(PureScript_CST_Types.TokBackslash.value);

58+})();

59+var tokColon = /* #__PURE__ */ (function () {

60+ return toSourceToken(new PureScript_CST_Types.TokOperator(Data_Maybe.Nothing.value, ":"));

61+})();

62+var tokComma = /* #__PURE__ */ (function () {

63+ return toSourceToken(PureScript_CST_Types.TokComma.value);

64+})();

65+var tokDot = /* #__PURE__ */ (function () {

66+ return toSourceToken(PureScript_CST_Types.TokDot.value);

67+})();

68+var tokDoubleColon = /* #__PURE__ */ (function () {

69+ return toSourceToken(new PureScript_CST_Types.TokDoubleColon(PureScript_CST_Types.ASCII.value));

70+})();

71+var tokEquals = /* #__PURE__ */ (function () {

72+ return toSourceToken(PureScript_CST_Types.TokEquals.value);

73+})();

74+var tokForall = /* #__PURE__ */ (function () {

75+ return toSourceToken(new PureScript_CST_Types.TokForall(PureScript_CST_Types.ASCII.value));

76+})();

77+var tokKeyword = /* #__PURE__ */ (function () {

78+ var $36 = PureScript_CST_Types.TokLowerName.create(Data_Maybe.Nothing.value);

79+ return function ($37) {

80+ return toSourceToken($36($37));

81+ };

82+})();

83+var tokAdo = /* #__PURE__ */ tokKeyword("ado");

84+var tokAs = /* #__PURE__ */ tokKeyword("as");

85+var tokCase = /* #__PURE__ */ tokKeyword("case");

86+var tokClass = /* #__PURE__ */ tokKeyword("class");

87+var tokData = /* #__PURE__ */ tokKeyword("data");

88+var tokDerive = /* #__PURE__ */ tokKeyword("derive");

89+var tokDo = /* #__PURE__ */ tokKeyword("do");

90+var tokElse = /* #__PURE__ */ tokKeyword("else");

91+var tokFalse = /* #__PURE__ */ tokKeyword("false");

92+var tokForeign = /* #__PURE__ */ tokKeyword("foreign");

93+var tokHiding = /* #__PURE__ */ tokKeyword("hiding");

94+var tokIf = /* #__PURE__ */ tokKeyword("if");

95+var tokImport = /* #__PURE__ */ tokKeyword("import");

96+var tokIn = /* #__PURE__ */ tokKeyword("in");

97+var tokInfix = /* #__PURE__ */ tokKeyword("infix");

98+var tokInfixl = /* #__PURE__ */ tokKeyword("infixl");

99+var tokInfixr = /* #__PURE__ */ tokKeyword("infixr");

100+var tokForFixity = function (v) {

101+ if (v instanceof PureScript_CST_Types.Infix) {

102+ return tokInfix;

103+ };

104+ if (v instanceof PureScript_CST_Types.Infixl) {

105+ return tokInfixl;

106+ };

107+ if (v instanceof PureScript_CST_Types.Infixr) {

108+ return tokInfixr;

109+ };

110+ throw new Error("Failed pattern match at Tidy.Codegen.Common (line 188, column 16 - line 191, column 22): " + [ v.constructor.name ]);

111+};

112+var tokInstance = /* #__PURE__ */ tokKeyword("instance");

113+var tokLet = /* #__PURE__ */ tokKeyword("let");

114+var tokModule = /* #__PURE__ */ tokKeyword("module");

115+var tokNewtype = /* #__PURE__ */ tokKeyword("newtype");

116+var tokNominal = /* #__PURE__ */ tokKeyword("nominal");

117+var tokOf = /* #__PURE__ */ tokKeyword("of");

118+var tokPhantom = /* #__PURE__ */ tokKeyword("phantom");

119+var tokRepresentational = /* #__PURE__ */ tokKeyword("representational");

120+var tokForRole = function (v) {

121+ if (v instanceof PureScript_CST_Types.Nominal) {

122+ return tokNominal;

123+ };

124+ if (v instanceof PureScript_CST_Types.Representational) {

125+ return tokRepresentational;

126+ };

127+ if (v instanceof PureScript_CST_Types.Phantom) {

128+ return tokPhantom;

129+ };

130+ throw new Error("Failed pattern match at Tidy.Codegen.Common (line 194, column 14 - line 197, column 24): " + [ v.constructor.name ]);

131+};

132+var tokRole = /* #__PURE__ */ tokKeyword("role");

133+var tokThen = /* #__PURE__ */ tokKeyword("then");

134+var tokTrue = /* #__PURE__ */ tokKeyword("true");

135+var tokType = /* #__PURE__ */ tokKeyword("type");

136+var tokWhere = /* #__PURE__ */ tokKeyword("where");

137+var tokLeftArrow = /* #__PURE__ */ (function () {

138+ return toSourceToken(new PureScript_CST_Types.TokLeftArrow(PureScript_CST_Types.ASCII.value));

139+})();

140+var tokLeftBrace = /* #__PURE__ */ (function () {

141+ return toSourceToken(PureScript_CST_Types.TokLeftBrace.value);

142+})();

143+var tokLeftFatArrow = /* #__PURE__ */ (function () {

144+ return toSourceToken(new PureScript_CST_Types.TokOperator(Data_Maybe.Nothing.value, "<="));

145+})();

146+var tokLeftParen = /* #__PURE__ */ (function () {

147+ return toSourceToken(PureScript_CST_Types.TokLeftParen.value);

148+})();

149+var tokLeftSquare = /* #__PURE__ */ (function () {

150+ return toSourceToken(PureScript_CST_Types.TokLeftSquare.value);

151+})();

152+var tokNegate = /* #__PURE__ */ (function () {

153+ return toSourceToken(new PureScript_CST_Types.TokOperator(Data_Maybe.Nothing.value, "-"));

154+})();

155+var tokPipe = /* #__PURE__ */ (function () {

156+ return toSourceToken(PureScript_CST_Types.TokPipe.value);

157+})();

158+var tokRightArrow = /* #__PURE__ */ (function () {

159+ return toSourceToken(new PureScript_CST_Types.TokRightArrow(PureScript_CST_Types.ASCII.value));

160+})();

161+var tokRightBrace = /* #__PURE__ */ (function () {

162+ return toSourceToken(PureScript_CST_Types.TokRightBrace.value);

163+})();

164+var tokRightFatArrow = /* #__PURE__ */ (function () {

165+ return toSourceToken(new PureScript_CST_Types.TokRightFatArrow(PureScript_CST_Types.ASCII.value));

166+})();

167+var tokRightParen = /* #__PURE__ */ (function () {

168+ return toSourceToken(PureScript_CST_Types.TokRightParen.value);

169+})();

170+var tokRightSquare = /* #__PURE__ */ (function () {

171+ return toSourceToken(PureScript_CST_Types.TokRightSquare.value);

172+})();

173+var tokSymbolArrow = /* #__PURE__ */ (function () {

174+ return toSourceToken(new PureScript_CST_Types.TokSymbolArrow(PureScript_CST_Types.ASCII.value));

175+})();

176+var tokTick = /* #__PURE__ */ (function () {

177+ return toSourceToken(PureScript_CST_Types.TokTick.value);

178+})();

179+var tokUnderscore = /* #__PURE__ */ (function () {

180+ return toSourceToken(PureScript_CST_Types.TokUnderscore.value);

181+})();

182+var toSeparated = function (tok) {

183+ return function (arr) {

184+ return {

185+ head: Data_Array_NonEmpty.head(arr),

186+ tail: map(Data_Tuple.Tuple.create(tok))(Data_Array_NonEmpty.tail(arr))

187+ };

188+ };

189+};

190+var toOneOrDelimited = function (arr) {

191+ var $34 = Data_Array_NonEmpty.length(arr) === 1;

192+ if ($34) {

193+ return new PureScript_CST_Types.One(Data_Array_NonEmpty.head(arr));

194+ };

195+ return new PureScript_CST_Types.Many({

196+ close: tokRightParen,

197+ open: tokLeftParen,

198+ value: toSeparated(tokComma)(arr)

199+ });

200+};

201+var toDelimitedNonEmpty = function (open) {

202+ return function (close) {

203+ return function (sep) {

204+ return function (value) {

205+ return toWrapped(open)(close)(toSeparated(sep)(value));

206+ };

207+ };

208+ };

209+};

210+var toParenList = /* #__PURE__ */ toDelimitedNonEmpty(tokLeftParen)(tokRightParen)(tokComma);

211+var toDelimited = function (open) {

212+ return function (close) {

213+ return function (sep) {

214+ return function (value) {

215+ return toWrapped(open)(close)(map1(toSeparated(sep))(Data_Array_NonEmpty.fromArray(value)));

216+ };

217+ };

218+ };

219+};

220+export {

221+ zeroRange,

222+ toSourceToken,

223+ tokUnderscore,

224+ tokPipe,

225+ tokColon,

226+ tokDoubleColon,

227+ tokForall,

228+ tokSymbolArrow,

229+ tokRightParen,

230+ tokLeftParen,

231+ tokRightBrace,

232+ tokLeftBrace,

233+ tokRightSquare,

234+ tokLeftSquare,

235+ tokTick,

236+ tokNegate,

237+ tokDot,

238+ tokComma,

239+ tokEquals,

240+ tokBackslash,

241+ tokRightArrow,

242+ tokRightFatArrow,

243+ tokLeftArrow,

244+ tokLeftFatArrow,

245+ tokAt,

246+ tokAll,

247+ tokIf,

248+ tokThen,

249+ tokElse,

250+ tokCase,

251+ tokOf,

252+ tokWhere,

253+ tokData,

254+ tokClass,

255+ tokNewtype,

256+ tokType,

257+ tokInstance,

258+ tokDerive,

259+ tokInfix,

260+ tokInfixl,

261+ tokInfixr,

262+ tokRole,

263+ tokRepresentational,

264+ tokPhantom,

265+ tokNominal,

266+ tokImport,

267+ tokAs,

268+ tokDo,

269+ tokAdo,

270+ tokLet,

271+ tokIn,

272+ tokModule,

273+ tokTrue,

274+ tokFalse,

275+ tokForeign,

276+ tokHiding,

277+ tokKeyword,

278+ tokForFixity,

279+ tokForRole,

280+ toSeparated,

281+ toOneOrDelimited,

282+ toDelimitedNonEmpty,

283+ toDelimited,

284+ toWrapped,

285+ toParenList

286+};

output-compile-fail/Tidy.Codegen.Monad/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.Monad/index.jsnew file+1027

@@ -0,0 +1,1027 @@

1+// Generated by purs version 0.15.15

2+import * as Control_Applicative from "../Control.Applicative/index.js";

3+import * as Control_Apply from "../Control.Apply/index.js";

4+import * as Control_Bind from "../Control.Bind/index.js";

5+import * as Control_Category from "../Control.Category/index.js";

6+import * as Control_Monad_Free from "../Control.Monad.Free/index.js";

7+import * as Control_Monad_ST_Class from "../Control.Monad.ST.Class/index.js";

8+import * as Control_Monad_State_Class from "../Control.Monad.State.Class/index.js";

9+import * as Control_Monad_State_Trans from "../Control.Monad.State.Trans/index.js";

10+import * as Control_Monad_Trans_Class from "../Control.Monad.Trans.Class/index.js";

11+import * as Control_Semigroupoid from "../Control.Semigroupoid/index.js";

12+import * as Data_Array from "../Data.Array/index.js";

13+import * as Data_Array_NonEmpty_Internal from "../Data.Array.NonEmpty.Internal/index.js";

14+import * as Data_Either from "../Data.Either/index.js";

15+import * as Data_Eq from "../Data.Eq/index.js";

16+import * as Data_Foldable from "../Data.Foldable/index.js";

17+import * as Data_Function from "../Data.Function/index.js";

18+import * as Data_Functor from "../Data.Functor/index.js";

19+import * as Data_Identity from "../Data.Identity/index.js";

20+import * as Data_List from "../Data.List/index.js";

21+import * as Data_List_Types from "../Data.List.Types/index.js";

22+import * as Data_Map_Internal from "../Data.Map.Internal/index.js";

23+import * as Data_Maybe from "../Data.Maybe/index.js";

24+import * as Data_Monoid from "../Data.Monoid/index.js";

25+import * as Data_Ord from "../Data.Ord/index.js";

26+import * as Data_Ordering from "../Data.Ordering/index.js";

27+import * as Data_Semigroup from "../Data.Semigroup/index.js";

28+import * as Data_Set from "../Data.Set/index.js";

29+import * as Data_Tuple from "../Data.Tuple/index.js";

30+import * as Data_Unfoldable from "../Data.Unfoldable/index.js";

31+import * as Data_Unit from "../Data.Unit/index.js";

32+import * as Effect_Class from "../Effect.Class/index.js";

33+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

34+import * as Record from "../Record/index.js";

35+import * as Record_Builder from "../Record.Builder/index.js";

36+import * as Safe_Coerce from "../Safe.Coerce/index.js";

37+import * as Tidy_Codegen from "../Tidy.Codegen/index.js";

38+import * as Tidy_Codegen_Class from "../Tidy.Codegen.Class/index.js";

39+import * as Tidy_Codegen_Common from "../Tidy.Codegen.Common/index.js";

40+import * as Tidy_Codegen_Types from "../Tidy.Codegen.Types/index.js";

41+import * as Type_Proxy from "../Type.Proxy/index.js";

42+var identity = /* #__PURE__ */ Control_Category.identity(Record_Builder.categoryBuilder);

43+var eq1 = /* #__PURE__ */ Data_Eq.eq(PureScript_CST_Types.eqProper);

44+var eq2 = /* #__PURE__ */ Data_Eq.eq(Tidy_Codegen_Types.eqSymbolName);

45+var eq3 = /* #__PURE__ */ Data_Eq.eq(PureScript_CST_Types.eqIdent);

46+var compare = /* #__PURE__ */ Data_Ord.compare(Data_Ord.ordBoolean);

47+var compare1 = /* #__PURE__ */ Data_Ord.compare(PureScript_CST_Types.ordProper);

48+var compare2 = /* #__PURE__ */ Data_Ord.compare(Tidy_Codegen_Types.ordSymbolName);

49+var compare3 = /* #__PURE__ */ Data_Ord.compare(PureScript_CST_Types.ordIdent);

50+var eq4 = /* #__PURE__ */ Data_Eq.eq(PureScript_CST_Types.eqModuleName);

51+var compare4 = /* #__PURE__ */ Data_Ord.compare(PureScript_CST_Types.ordModuleName);

52+var compose1 = /* #__PURE__ */ Control_Semigroupoid.compose(Record_Builder.semigroupoidBuilder);

53+var insert = /* #__PURE__ */ Record_Builder.insert()();

54+var toQualifiedName = /* #__PURE__ */ Tidy_Codegen_Class.toQualifiedName(Tidy_Codegen_Class.toQualifiedNameQualifiedN2);

55+var insert1 = /* #__PURE__ */ Data_Set.insert(PureScript_CST_Types.ordModuleName);

56+var alter = /* #__PURE__ */ Data_Map_Internal.alter(PureScript_CST_Types.ordModuleName);

57+var discard = /* #__PURE__ */ Control_Bind.discard(Control_Bind.discardUnit);

58+var importTypeAll1 = /* #__PURE__ */ Tidy_Codegen.importTypeAll(Tidy_Codegen_Class.toNameProperProper);

59+var importType1 = /* #__PURE__ */ Tidy_Codegen.importType(Tidy_Codegen_Class.toNameProperProper);

60+var importTypeOp1 = /* #__PURE__ */ Tidy_Codegen.importTypeOp(Tidy_Codegen_Class.toNameSymbolNameSymbolNam);

61+var importClass1 = /* #__PURE__ */ Tidy_Codegen.importClass(Tidy_Codegen_Class.toNameProperProper);

62+var importValue1 = /* #__PURE__ */ Tidy_Codegen.importValue(Tidy_Codegen_Class.toNameIdentIdent);

63+var importOp1 = /* #__PURE__ */ Tidy_Codegen.importOp(Tidy_Codegen_Class.toNameSymbolNameSymbolNam);

64+var exportTypeAll1 = /* #__PURE__ */ Tidy_Codegen.exportTypeAll(Tidy_Codegen_Class.toNameProperProper);

65+var exportType1 = /* #__PURE__ */ Tidy_Codegen.exportType(Tidy_Codegen_Class.toNameProperProper);

66+var exportTypeOp1 = /* #__PURE__ */ Tidy_Codegen.exportTypeOp(Tidy_Codegen_Class.toNameSymbolNameSymbolNam);

67+var exportClass1 = /* #__PURE__ */ Tidy_Codegen.exportClass(Tidy_Codegen_Class.toNameProperProper);

68+var exportValue1 = /* #__PURE__ */ Tidy_Codegen.exportValue(Tidy_Codegen_Class.toNameIdentIdent);

69+var exportOp1 = /* #__PURE__ */ Tidy_Codegen.exportOp(Tidy_Codegen_Class.toNameSymbolNameSymbolNam);

70+var exportModule1 = /* #__PURE__ */ Tidy_Codegen.exportModule(Tidy_Codegen_Class.toNameModuleNameModuleNam);

71+var fold = /* #__PURE__ */ Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidArray);

72+var leading = /* #__PURE__ */ Tidy_Codegen.leading(Tidy_Codegen_Class.overLeadingCommentsImport);

73+var bind = /* #__PURE__ */ Control_Bind.bind(Control_Bind.bindArray);

74+var toUnfoldable = /* #__PURE__ */ Data_Map_Internal.toUnfoldable(Data_Unfoldable.unfoldableArray);

75+var toUnfoldable1 = /* #__PURE__ */ Data_Set.toUnfoldable(Data_Unfoldable.unfoldableArray);

76+var pure = /* #__PURE__ */ Control_Applicative.pure(Control_Applicative.applicativeArray);

77+var declImportAs = /* #__PURE__ */ Tidy_Codegen.declImportAs(Tidy_Codegen_Class.toNameModuleNameModuleNam)(Tidy_Codegen_Class.toNameModuleNameModuleNam);

78+var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorArray);

79+var declImport = /* #__PURE__ */ Tidy_Codegen.declImport(Tidy_Codegen_Class.toNameModuleNameModuleNam);

80+var fromFoldable = /* #__PURE__ */ Data_Array.fromFoldable(Data_Set.foldableSet);

81+var identity1 = /* #__PURE__ */ Control_Category.identity(Control_Category.categoryFn);

82+var comparing = /* #__PURE__ */ Data_Ord.comparing(PureScript_CST_Types.ordModuleName);

83+var append = /* #__PURE__ */ Data_Semigroup.append(Data_Semigroup.semigroupArray);

84+var map1 = /* #__PURE__ */ Data_Functor.map(Data_Tuple.functorTuple);

85+var fromFoldable1 = /* #__PURE__ */ Data_Array.fromFoldable(Data_List_Types.foldableList);

86+var runFree = /* #__PURE__ */ Control_Monad_Free.runFree(Data_Identity.functorIdentity);

87+var coerce = /* #__PURE__ */ Safe_Coerce.coerce();

88+var CodegenImportType = /* #__PURE__ */ (function () {

89+ function CodegenImportType(value0, value1) {

90+ this.value0 = value0;

91+ this.value1 = value1;

92+ };

93+ CodegenImportType.create = function (value0) {

94+ return function (value1) {

95+ return new CodegenImportType(value0, value1);

96+ };

97+ };

98+ return CodegenImportType;

99+})();

100+var CodegenImportTypeOp = /* #__PURE__ */ (function () {

101+ function CodegenImportTypeOp(value0) {

102+ this.value0 = value0;

103+ };

104+ CodegenImportTypeOp.create = function (value0) {

105+ return new CodegenImportTypeOp(value0);

106+ };

107+ return CodegenImportTypeOp;

108+})();

109+var CodegenImportClass = /* #__PURE__ */ (function () {

110+ function CodegenImportClass(value0) {

111+ this.value0 = value0;

112+ };

113+ CodegenImportClass.create = function (value0) {

114+ return new CodegenImportClass(value0);

115+ };

116+ return CodegenImportClass;

117+})();

118+var CodegenImportValue = /* #__PURE__ */ (function () {

119+ function CodegenImportValue(value0) {

120+ this.value0 = value0;

121+ };

122+ CodegenImportValue.create = function (value0) {

123+ return new CodegenImportValue(value0);

124+ };

125+ return CodegenImportValue;

126+})();

127+var CodegenImportOp = /* #__PURE__ */ (function () {

128+ function CodegenImportOp(value0) {

129+ this.value0 = value0;

130+ };

131+ CodegenImportOp.create = function (value0) {

132+ return new CodegenImportOp(value0);

133+ };

134+ return CodegenImportOp;

135+})();

136+var ImportName = /* #__PURE__ */ (function () {

137+ function ImportName(value0, value1) {

138+ this.value0 = value0;

139+ this.value1 = value1;

140+ };

141+ ImportName.create = function (value0) {

142+ return function (value1) {

143+ return new ImportName(value0, value1);

144+ };

145+ };

146+ return ImportName;

147+})();

148+var CodegenExportType = /* #__PURE__ */ (function () {

149+ function CodegenExportType(value0, value1) {

150+ this.value0 = value0;

151+ this.value1 = value1;

152+ };

153+ CodegenExportType.create = function (value0) {

154+ return function (value1) {

155+ return new CodegenExportType(value0, value1);

156+ };

157+ };

158+ return CodegenExportType;

159+})();

160+var CodegenExportTypeOp = /* #__PURE__ */ (function () {

161+ function CodegenExportTypeOp(value0) {

162+ this.value0 = value0;

163+ };

164+ CodegenExportTypeOp.create = function (value0) {

165+ return new CodegenExportTypeOp(value0);

166+ };

167+ return CodegenExportTypeOp;

168+})();

169+var CodegenExportClass = /* #__PURE__ */ (function () {

170+ function CodegenExportClass(value0) {

171+ this.value0 = value0;

172+ };

173+ CodegenExportClass.create = function (value0) {

174+ return new CodegenExportClass(value0);

175+ };

176+ return CodegenExportClass;

177+})();

178+var CodegenExportValue = /* #__PURE__ */ (function () {

179+ function CodegenExportValue(value0) {

180+ this.value0 = value0;

181+ };

182+ CodegenExportValue.create = function (value0) {

183+ return new CodegenExportValue(value0);

184+ };

185+ return CodegenExportValue;

186+})();

187+var CodegenExportOp = /* #__PURE__ */ (function () {

188+ function CodegenExportOp(value0) {

189+ this.value0 = value0;

190+ };

191+ CodegenExportOp.create = function (value0) {

192+ return new CodegenExportOp(value0);

193+ };

194+ return CodegenExportOp;

195+})();

196+var CodegenExportModule = /* #__PURE__ */ (function () {

197+ function CodegenExportModule(value0) {

198+ this.value0 = value0;

199+ };

200+ CodegenExportModule.create = function (value0) {

201+ return new CodegenExportModule(value0);

202+ };

203+ return CodegenExportModule;

204+})();

205+var CodegenT = function (x) {

206+ return x;

207+};

208+var toImportFromRecordNilReco = {

209+ toImportFromRecord: function (dictApplicative) {

210+ var pure1 = Control_Applicative.pure(dictApplicative);

211+ return function (v) {

212+ return function (v1) {

213+ return function (v2) {

214+ return pure1(identity);

215+ };

216+ };

217+ };

218+ }

219+};

220+var toImportFromImportNameQua = {

221+ toImportFrom: function (dictApplicative) {

222+ return Data_Function.apply;

223+ }

224+};

225+var monadTransCodegenT = Control_Monad_State_Trans.monadTransStateT;

226+var lift = /* #__PURE__ */ Control_Monad_Trans_Class.lift(monadTransCodegenT);

227+var monadCodegenT = function (dictMonad) {

228+ return Control_Monad_State_Trans.monadStateT(dictMonad);

229+};

230+var monadEffectCodegenT = function (dictMonadEffect) {

231+ var Monad0 = dictMonadEffect.Monad0();

232+ var monadCodegenT1 = monadCodegenT(Monad0);

233+ return {

234+ liftEffect: (function () {

235+ var $526 = lift(Monad0);

236+ var $527 = Effect_Class.liftEffect(dictMonadEffect);

237+ return function ($528) {

238+ return $526($527($528));

239+ };

240+ })(),

241+ Monad0: function () {

242+ return monadCodegenT1;

243+ }

244+ };

245+};

246+var monadSTCodegenT = function (dictMonad) {

247+ var lift1 = lift(dictMonad);

248+ var monadCodegenT1 = monadCodegenT(dictMonad);

249+ return function (dictMonadST) {

250+ return {

251+ liftST: (function () {

252+ var $529 = Control_Monad_ST_Class.liftST(dictMonadST);

253+ return function ($530) {

254+ return lift1($529($530));

255+ };

256+ })(),

257+ Monad0: function () {

258+ return monadCodegenT1;

259+ }

260+ };

261+ };

262+};

263+var functorCodegenT = function (dictFunctor) {

264+ return Control_Monad_State_Trans.functorStateT(dictFunctor);

265+};

266+var eqCodegenImport = {

267+ eq: function (x) {

268+ return function (y) {

269+ if (x instanceof CodegenImportType && y instanceof CodegenImportType) {

270+ return x.value0 === y.value0 && eq1(x.value1)(y.value1);

271+ };

272+ if (x instanceof CodegenImportTypeOp && y instanceof CodegenImportTypeOp) {

273+ return eq2(x.value0)(y.value0);

274+ };

275+ if (x instanceof CodegenImportClass && y instanceof CodegenImportClass) {

276+ return eq1(x.value0)(y.value0);

277+ };

278+ if (x instanceof CodegenImportValue && y instanceof CodegenImportValue) {

279+ return eq3(x.value0)(y.value0);

280+ };

281+ if (x instanceof CodegenImportOp && y instanceof CodegenImportOp) {

282+ return eq2(x.value0)(y.value0);

283+ };

284+ return false;

285+ };

286+ }

287+};

288+var ordCodegenImport = {

289+ compare: function (x) {

290+ return function (y) {

291+ if (x instanceof CodegenImportType && y instanceof CodegenImportType) {

292+ var v = compare(x.value0)(y.value0);

293+ if (v instanceof Data_Ordering.LT) {

294+ return Data_Ordering.LT.value;

295+ };

296+ if (v instanceof Data_Ordering.GT) {

297+ return Data_Ordering.GT.value;

298+ };

299+ return compare1(x.value1)(y.value1);

300+ };

301+ if (x instanceof CodegenImportType) {

302+ return Data_Ordering.LT.value;

303+ };

304+ if (y instanceof CodegenImportType) {

305+ return Data_Ordering.GT.value;

306+ };

307+ if (x instanceof CodegenImportTypeOp && y instanceof CodegenImportTypeOp) {

308+ return compare2(x.value0)(y.value0);

309+ };

310+ if (x instanceof CodegenImportTypeOp) {

311+ return Data_Ordering.LT.value;

312+ };

313+ if (y instanceof CodegenImportTypeOp) {

314+ return Data_Ordering.GT.value;

315+ };

316+ if (x instanceof CodegenImportClass && y instanceof CodegenImportClass) {

317+ return compare1(x.value0)(y.value0);

318+ };

319+ if (x instanceof CodegenImportClass) {

320+ return Data_Ordering.LT.value;

321+ };

322+ if (y instanceof CodegenImportClass) {

323+ return Data_Ordering.GT.value;

324+ };

325+ if (x instanceof CodegenImportValue && y instanceof CodegenImportValue) {

326+ return compare3(x.value0)(y.value0);

327+ };

328+ if (x instanceof CodegenImportValue) {

329+ return Data_Ordering.LT.value;

330+ };

331+ if (y instanceof CodegenImportValue) {

332+ return Data_Ordering.GT.value;

333+ };

334+ if (x instanceof CodegenImportOp && y instanceof CodegenImportOp) {

335+ return compare2(x.value0)(y.value0);

336+ };

337+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 0, column 0 - line 0, column 0): " + [ x.constructor.name, y.constructor.name ]);

338+ };

339+ },

340+ Eq0: function () {

341+ return eqCodegenImport;

342+ }

343+};

344+var insert2 = /* #__PURE__ */ Data_Set.insert(ordCodegenImport);

345+var $$delete = /* #__PURE__ */ Data_Set["delete"](ordCodegenImport);

346+var member = /* #__PURE__ */ Data_Set.member(ordCodegenImport);

347+var eqCodegenExport = {

348+ eq: function (x) {

349+ return function (y) {

350+ if (x instanceof CodegenExportType && y instanceof CodegenExportType) {

351+ return x.value0 === y.value0 && eq1(x.value1)(y.value1);

352+ };

353+ if (x instanceof CodegenExportTypeOp && y instanceof CodegenExportTypeOp) {

354+ return eq2(x.value0)(y.value0);

355+ };

356+ if (x instanceof CodegenExportClass && y instanceof CodegenExportClass) {

357+ return eq1(x.value0)(y.value0);

358+ };

359+ if (x instanceof CodegenExportValue && y instanceof CodegenExportValue) {

360+ return eq3(x.value0)(y.value0);

361+ };

362+ if (x instanceof CodegenExportOp && y instanceof CodegenExportOp) {

363+ return eq2(x.value0)(y.value0);

364+ };

365+ if (x instanceof CodegenExportModule && y instanceof CodegenExportModule) {

366+ return eq4(x.value0)(y.value0);

367+ };

368+ return false;

369+ };

370+ }

371+};

372+var ordCodegenExport = {

373+ compare: function (x) {

374+ return function (y) {

375+ if (x instanceof CodegenExportType && y instanceof CodegenExportType) {

376+ var v = compare(x.value0)(y.value0);

377+ if (v instanceof Data_Ordering.LT) {

378+ return Data_Ordering.LT.value;

379+ };

380+ if (v instanceof Data_Ordering.GT) {

381+ return Data_Ordering.GT.value;

382+ };

383+ return compare1(x.value1)(y.value1);

384+ };

385+ if (x instanceof CodegenExportType) {

386+ return Data_Ordering.LT.value;

387+ };

388+ if (y instanceof CodegenExportType) {

389+ return Data_Ordering.GT.value;

390+ };

391+ if (x instanceof CodegenExportTypeOp && y instanceof CodegenExportTypeOp) {

392+ return compare2(x.value0)(y.value0);

393+ };

394+ if (x instanceof CodegenExportTypeOp) {

395+ return Data_Ordering.LT.value;

396+ };

397+ if (y instanceof CodegenExportTypeOp) {

398+ return Data_Ordering.GT.value;

399+ };

400+ if (x instanceof CodegenExportClass && y instanceof CodegenExportClass) {

401+ return compare1(x.value0)(y.value0);

402+ };

403+ if (x instanceof CodegenExportClass) {

404+ return Data_Ordering.LT.value;

405+ };

406+ if (y instanceof CodegenExportClass) {

407+ return Data_Ordering.GT.value;

408+ };

409+ if (x instanceof CodegenExportValue && y instanceof CodegenExportValue) {

410+ return compare3(x.value0)(y.value0);

411+ };

412+ if (x instanceof CodegenExportValue) {

413+ return Data_Ordering.LT.value;

414+ };

415+ if (y instanceof CodegenExportValue) {

416+ return Data_Ordering.GT.value;

417+ };

418+ if (x instanceof CodegenExportOp && y instanceof CodegenExportOp) {

419+ return compare2(x.value0)(y.value0);

420+ };

421+ if (x instanceof CodegenExportOp) {

422+ return Data_Ordering.LT.value;

423+ };

424+ if (y instanceof CodegenExportOp) {

425+ return Data_Ordering.GT.value;

426+ };

427+ if (x instanceof CodegenExportModule && y instanceof CodegenExportModule) {

428+ return compare4(x.value0)(y.value0);

429+ };

430+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 0, column 0 - line 0, column 0): " + [ x.constructor.name, y.constructor.name ]);

431+ };

432+ },

433+ Eq0: function () {

434+ return eqCodegenExport;

435+ }

436+};

437+var member1 = /* #__PURE__ */ Data_Set.member(ordCodegenExport);

438+var insert3 = /* #__PURE__ */ Data_Set.insert(ordCodegenExport);

439+var delete1 = /* #__PURE__ */ Data_Set["delete"](ordCodegenExport);

440+var bindCodegenT = function (dictMonad) {

441+ return Control_Monad_State_Trans.bindStateT(dictMonad);

442+};

443+var applyCodegenT = function (dictMonad) {

444+ return Control_Monad_State_Trans.applyStateT(dictMonad);

445+};

446+var applicativeCodegenT = function (dictMonad) {

447+ return Control_Monad_State_Trans.applicativeStateT(dictMonad);

448+};

449+var write = function (dictMonad) {

450+ var modify_ = Control_Monad_State_Class.modify_(Control_Monad_State_Trans.monadStateStateT(dictMonad));

451+ return function (decl) {

452+ return modify_(function (st) {

453+ var $398 = {};

454+ for (var $399 in st) {

455+ if ({}.hasOwnProperty.call(st, $399)) {

456+ $398[$399] = st[$399];

457+ };

458+ };

459+ $398.declarations = new Data_List_Types.Cons(decl, st.declarations);

460+ return $398;

461+ });

462+ };

463+};

464+var monadTellArrayDeclaration = function (dictMonad) {

465+ var monadCodegenT1 = monadCodegenT(dictMonad);

466+ return {

467+ tell: Data_Foldable.traverse_(applicativeCodegenT(dictMonad))(Data_Foldable.foldableArray)(write(dictMonad)),

468+ Semigroup0: function () {

469+ return Data_Semigroup.semigroupArray;

470+ },

471+ Monad1: function () {

472+ return monadCodegenT1;

473+ }

474+ };

475+};

476+var withQualifiedName = function (dictToToken) {

477+ var toToken = Tidy_Codegen_Class.toToken(dictToToken);

478+ return function (k) {

479+ return function (from) {

480+ var v = toToken(from);

481+ return k(v.value1.value1)({

482+ module: v.value1.value0,

483+ name: v.value1.value1,

484+ token: Tidy_Codegen_Common.toSourceToken(v.value0)

485+ });

486+ };

487+ };

488+};

489+var toImportFromRecord = function (dict) {

490+ return dict.toImportFromRecord;

491+};

492+var toImportFromRecordRecord = function () {

493+ return function (dictToImportFromRecord) {

494+ var toImportFromRecord1 = toImportFromRecord(dictToImportFromRecord);

495+ return {

496+ toImportFrom: function (dictApplicative) {

497+ var map2 = Data_Functor.map((dictApplicative.Apply0()).Functor0());

498+ var toImportFromRecord2 = toImportFromRecord1(dictApplicative);

499+ return function (k) {

500+ var $531 = map2(Record_Builder.buildFromScratch);

501+ var $532 = toImportFromRecord2(k)(Type_Proxy["Proxy"].value);

502+ return function ($533) {

503+ return $531($532($533));

504+ };

505+ };

506+ }

507+ };

508+ };

509+};

510+var toImportFrom = function (dict) {

511+ return dict.toImportFrom;

512+};

513+var toImportFromRecordConsRec = function (dictToImportFrom) {

514+ var toImportFrom1 = toImportFrom(dictToImportFrom);

515+ return function (dictToImportFromRecord) {

516+ var toImportFromRecord1 = toImportFromRecord(dictToImportFromRecord);

517+ return function (dictIsSymbol) {

518+ var insert4 = insert(dictIsSymbol);

519+ var get = Record.get(dictIsSymbol)();

520+ return function () {

521+ return function () {

522+ return function () {

523+ return {

524+ toImportFromRecord: function (dictApplicative) {

525+ var Apply0 = dictApplicative.Apply0();

526+ var apply = Control_Apply.apply(Apply0);

527+ var map2 = Data_Functor.map(Apply0.Functor0());

528+ var toImportFrom2 = toImportFrom1(dictApplicative);

529+ var toImportFromRecord2 = toImportFromRecord1(dictApplicative);

530+ return function (k) {

531+ return function (v) {

532+ return function (r) {

533+ return apply(map2(function (imp) {

534+ return function (builder) {

535+ return compose1(insert4(Type_Proxy["Proxy"].value)(imp))(builder);

536+ };

537+ })(toImportFrom2(k)(get(Type_Proxy["Proxy"].value)(r))))(toImportFromRecord2(k)(Type_Proxy["Proxy"].value)(r));

538+ };

539+ };

540+ };

541+ }

542+ };

543+ };

544+ };

545+ };

546+ };

547+ };

548+};

549+var runCodegenT = function (v) {

550+ return Control_Monad_State_Trans.runStateT(v)({

551+ exports: Data_Set.empty,

552+ importsOpen: Data_Set.empty,

553+ importsFrom: Data_Map_Internal.empty,

554+ importsQualified: Data_Map_Internal.empty,

555+ declarations: Data_List_Types.Nil.value

556+ });

557+};

558+var importValue = function (dictToToken) {

559+ return withQualifiedName(dictToToken)(function ($534) {

560+ return ImportName.create(CodegenImportValue.create($534));

561+ });

562+};

563+var importTypeOp = function (dictToToken) {

564+ return withQualifiedName(dictToToken)(function (a) {

565+ return function (b) {

566+ return new ImportName(new CodegenImportTypeOp(a), toQualifiedName(b));

567+ };

568+ });

569+};

570+var importTypeAll = function (dictToToken) {

571+ return withQualifiedName(dictToToken)((function () {

572+ var $535 = CodegenImportType.create(true);

573+ return function ($536) {

574+ return ImportName.create($535($536));

575+ };

576+ })());

577+};

578+var importType = function (dictToToken) {

579+ return withQualifiedName(dictToToken)((function () {

580+ var $537 = CodegenImportType.create(false);

581+ return function ($538) {

582+ return ImportName.create($537($538));

583+ };

584+ })());

585+};

586+var importOpen = function (dictMonad) {

587+ var modify_ = Control_Monad_State_Class.modify_(Control_Monad_State_Trans.monadStateStateT(dictMonad));

588+ return function (dictToModuleName) {

589+ var toModuleName = Tidy_Codegen_Class.toModuleName(dictToModuleName);

590+ return function (mod) {

591+ return modify_(function (st) {

592+ var $409 = {};

593+ for (var $410 in st) {

594+ if ({}.hasOwnProperty.call(st, $410)) {

595+ $409[$410] = st[$410];

596+ };

597+ };

598+ $409.importsOpen = insert1(toModuleName(mod))(st.importsOpen);

599+ return $409;

600+ });

601+ };

602+ };

603+};

604+var importOp = function (dictToToken) {

605+ return withQualifiedName(dictToToken)(function (a) {

606+ return function (b) {

607+ return new ImportName(new CodegenImportOp(a), toQualifiedName(b));

608+ };

609+ });

610+};

611+var importFrom = function (dictMonad) {

612+ var applicativeCodegenT1 = applicativeCodegenT(dictMonad);

613+ var state = Control_Monad_State_Class.state(Control_Monad_State_Trans.monadStateStateT(dictMonad));

614+ return function (dictToModuleName) {

615+ var toModuleName = Tidy_Codegen_Class.toModuleName(dictToModuleName);

616+ return function (dictToImportFrom) {

617+ var toImportFrom1 = toImportFrom(dictToImportFrom)(applicativeCodegenT1);

618+ return function (mod) {

619+ return toImportFrom1(function (v) {

620+ return state(function (st) {

621+ return new Data_Tuple.Tuple(v.value1, (function () {

622+ if (v.value1.module instanceof Data_Maybe.Nothing) {

623+ var $423 = {};

624+ for (var $424 in st) {

625+ if ({}.hasOwnProperty.call(st, $424)) {

626+ $423[$424] = st[$424];

627+ };

628+ };

629+ $423.importsFrom = alter(function (v2) {

630+ if (v.value0 instanceof CodegenImportType && (v.value0.value0 && v2 instanceof Data_Maybe.Just)) {

631+ return new Data_Maybe.Just(insert2(v.value0)($$delete(new CodegenImportType(false, v.value0.value1))(v2.value0)));

632+ };

633+ if (v.value0 instanceof CodegenImportType && (!v.value0.value0 && (v2 instanceof Data_Maybe.Just && member(new CodegenImportType(true, v.value0.value1))(v2.value0)))) {

634+ return new Data_Maybe.Just(v2.value0);

635+ };

636+ if (v2 instanceof Data_Maybe.Just) {

637+ return new Data_Maybe.Just(insert2(v.value0)(v2.value0));

638+ };

639+ if (v2 instanceof Data_Maybe.Nothing) {

640+ return new Data_Maybe.Just(Data_Set.singleton(v.value0));

641+ };

642+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 243, column 13 - line 251, column 41): " + [ v.value0.constructor.name, v2.constructor.name ]);

643+ })(toModuleName(mod))(st.importsFrom);

644+ return $423;

645+ };

646+ if (v.value1.module instanceof Data_Maybe.Just) {

647+ var $428 = {};

648+ for (var $429 in st) {

649+ if ({}.hasOwnProperty.call(st, $429)) {

650+ $428[$429] = st[$429];

651+ };

652+ };

653+ $428.importsQualified = alter(function (v2) {

654+ if (v2 instanceof Data_Maybe.Nothing) {

655+ return new Data_Maybe.Just(Data_Set.singleton(v.value1.module.value0));

656+ };

657+ if (v2 instanceof Data_Maybe.Just) {

658+ return new Data_Maybe.Just(insert1(v.value1.module.value0)(v2.value0));

659+ };

660+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 257, column 13 - line 259, column 54): " + [ v2.constructor.name ]);

661+ })(toModuleName(mod))(st.importsQualified);

662+ return $428;

663+ };

664+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 240, column 16 - line 262, column 10): " + [ v.value1.module.constructor.name ]);

665+ })());

666+ });

667+ });

668+ };

669+ };

670+ };

671+};

672+var importCtor = function (dictToToken) {

673+ var toToken = Tidy_Codegen_Class.toToken(dictToToken);

674+ return function (dictToToken1) {

675+ var $539 = withQualifiedName(dictToToken1);

676+ var $540 = CodegenImportType.create(true);

677+ return function ($541) {

678+ return $539(Data_Function["const"](ImportName.create($540(Data_Tuple.snd(toToken($541))))));

679+ };

680+ };

681+};

682+var importClass = function (dictToToken) {

683+ return withQualifiedName(dictToToken)(function ($542) {

684+ return ImportName.create(CodegenImportClass.create($542));

685+ });

686+};

687+var $$export = function (dictMonad) {

688+ var modify_ = Control_Monad_State_Class.modify_(Control_Monad_State_Trans.monadStateStateT(dictMonad));

689+ return function (exp) {

690+ return modify_(function (st) {

691+ var $440 = {};

692+ for (var $441 in st) {

693+ if ({}.hasOwnProperty.call(st, $441)) {

694+ $440[$441] = st[$441];

695+ };

696+ };

697+ $440.exports = (function () {

698+ if (exp instanceof CodegenExportType && (!exp.value0 && member1(new CodegenExportType(true, exp.value1))(st.exports))) {

699+ return st.exports;

700+ };

701+ if (exp instanceof CodegenExportType && exp.value0) {

702+ return insert3(exp)(delete1(new CodegenExportType(false, exp.value1))(st.exports));

703+ };

704+ return insert3(exp)(st.exports);

705+ })();

706+ return $440;

707+ });

708+ };

709+};

710+var exportClass = function (dictMonad) {

711+ var export1 = $$export(dictMonad);

712+ return function (dictToToken) {

713+ var $543 = Tidy_Codegen_Class.toToken(dictToToken);

714+ return function ($544) {

715+ return export1(CodegenExportClass.create(Data_Tuple.snd($543($544))));

716+ };

717+ };

718+};

719+var exportModule = function (dictMonad) {

720+ var export1 = $$export(dictMonad);

721+ return function (dictToToken) {

722+ var $545 = Tidy_Codegen_Class.toToken(dictToToken);

723+ return function ($546) {

724+ return export1(CodegenExportModule.create(Data_Tuple.snd($545($546))));

725+ };

726+ };

727+};

728+var exportOp = function (dictMonad) {

729+ var export1 = $$export(dictMonad);

730+ return function (dictToToken) {

731+ var $547 = Tidy_Codegen_Class.toToken(dictToToken);

732+ return function ($548) {

733+ return export1(CodegenExportOp.create(Data_Tuple.snd($547($548))));

734+ };

735+ };

736+};

737+var exportType = function (dictMonad) {

738+ var export1 = $$export(dictMonad);

739+ return function (dictToToken) {

740+ var $549 = CodegenExportType.create(false);

741+ var $550 = Tidy_Codegen_Class.toToken(dictToToken);

742+ return function ($551) {

743+ return export1($549(Data_Tuple.snd($550($551))));

744+ };

745+ };

746+};

747+var exportTypeAll = function (dictMonad) {

748+ var export1 = $$export(dictMonad);

749+ return function (dictToToken) {

750+ var $552 = CodegenExportType.create(true);

751+ var $553 = Tidy_Codegen_Class.toToken(dictToToken);

752+ return function ($554) {

753+ return export1($552(Data_Tuple.snd($553($554))));

754+ };

755+ };

756+};

757+var exportTypeOp = function (dictMonad) {

758+ var export1 = $$export(dictMonad);

759+ return function (dictToToken) {

760+ var $555 = Tidy_Codegen_Class.toToken(dictToToken);

761+ return function ($556) {

762+ return export1(CodegenExportTypeOp.create(Data_Tuple.snd($555($556))));

763+ };

764+ };

765+};

766+var exportValue = function (dictMonad) {

767+ var export1 = $$export(dictMonad);

768+ return function (dictToToken) {

769+ var $557 = Tidy_Codegen_Class.toToken(dictToToken);

770+ return function ($558) {

771+ return export1(CodegenExportValue.create(Data_Tuple.snd($557($558))));

772+ };

773+ };

774+};

775+var writeAndExport = function (dictMonad) {

776+ var discard1 = discard(bindCodegenT(dictMonad));

777+ var write1 = write(dictMonad);

778+ var exportType2 = exportType(dictMonad)(Tidy_Codegen_Class.toTokenProperProper);

779+ var exportTypeAll2 = exportTypeAll(dictMonad)(Tidy_Codegen_Class.toTokenProperProper);

780+ var exportClass2 = exportClass(dictMonad)(Tidy_Codegen_Class.toTokenProperProper);

781+ var applicativeCodegenT1 = applicativeCodegenT(dictMonad);

782+ var for_ = Data_Foldable.for_(applicativeCodegenT1);

783+ var for_1 = for_(Data_Foldable.foldableMaybe);

784+ var for_2 = for_(Data_Array_NonEmpty_Internal.foldableNonEmptyArray);

785+ var exportValue2 = exportValue(dictMonad)(Tidy_Codegen_Class.toTokenIdentIdent);

786+ var pure1 = Control_Applicative.pure(applicativeCodegenT1);

787+ return function (decl) {

788+ return discard1(write1(decl))(function () {

789+ if (decl instanceof PureScript_CST_Types.DeclData && decl.value1 instanceof Data_Maybe.Nothing) {

790+ return exportType2(decl.value0.name.name);

791+ };

792+ if (decl instanceof PureScript_CST_Types.DeclData && decl.value1 instanceof Data_Maybe.Just) {

793+ return exportTypeAll2(decl.value0.name.name);

794+ };

795+ if (decl instanceof PureScript_CST_Types.DeclType) {

796+ return exportType2(decl.value0.name.name);

797+ };

798+ if (decl instanceof PureScript_CST_Types.DeclNewtype) {

799+ return exportTypeAll2(decl.value0.name.name);

800+ };

801+ if (decl instanceof PureScript_CST_Types.DeclClass) {

802+ return discard1(exportClass2(decl.value0.name.name))(function () {

803+ return for_1(decl.value1)(function (v) {

804+ return for_2(v.value1)(function (v1) {

805+ return exportValue2(v1.label.name);

806+ });

807+ });

808+ });

809+ };

810+ if (decl instanceof PureScript_CST_Types.DeclKindSignature) {

811+ return exportType2(decl.value1.label.name);

812+ };

813+ if (decl instanceof PureScript_CST_Types.DeclSignature) {

814+ return exportValue2(decl.value0.label.name);

815+ };

816+ if (decl instanceof PureScript_CST_Types.DeclValue) {

817+ return exportValue2(decl.value0.name.name);

818+ };

819+ if (decl instanceof PureScript_CST_Types.DeclForeign && decl.value2 instanceof PureScript_CST_Types.ForeignData) {

820+ return exportType2(decl.value2.value1.label.name);

821+ };

822+ if (decl instanceof PureScript_CST_Types.DeclForeign && decl.value2 instanceof PureScript_CST_Types.ForeignValue) {

823+ return exportValue2(decl.value2.value0.label.name);

824+ };

825+ return pure1(Data_Unit.unit);

826+ });

827+ };

828+};

829+var exporting = function (dictMonad) {

830+ var bindCodegenT1 = bindCodegenT(dictMonad);

831+ var bind1 = Control_Bind.bind(bindCodegenT1);

832+ var state = Control_Monad_State_Class.state(Control_Monad_State_Trans.monadStateStateT(dictMonad));

833+ var discard1 = discard(bindCodegenT1);

834+ var applicativeCodegenT1 = applicativeCodegenT(dictMonad);

835+ var for_ = Data_Foldable.for_(applicativeCodegenT1)(Data_List_Types.foldableList);

836+ var writeAndExport1 = writeAndExport(dictMonad);

837+ var pure1 = Control_Applicative.pure(applicativeCodegenT1);

838+ return function (m) {

839+ return bind1(state(function (st) {

840+ return new Data_Tuple.Tuple(st.declarations, (function () {

841+ var $497 = {};

842+ for (var $498 in st) {

843+ if ({}.hasOwnProperty.call(st, $498)) {

844+ $497[$498] = st[$498];

845+ };

846+ };

847+ $497.declarations = Data_List_Types.Nil.value;

848+ return $497;

849+ })());

850+ }))(function (old) {

851+ return bind1(m)(function (res) {

852+ return bind1(state(function (st) {

853+ return new Data_Tuple.Tuple(st.declarations, (function () {

854+ var $500 = {};

855+ for (var $501 in st) {

856+ if ({}.hasOwnProperty.call(st, $501)) {

857+ $500[$501] = st[$501];

858+ };

859+ };

860+ $500.declarations = old;

861+ return $500;

862+ })());

863+ }))(function ($$new) {

864+ return discard1(for_(Data_List.reverse($$new))(writeAndExport1))(function () {

865+ return pure1(res);

866+ });

867+ });

868+ });

869+ });

870+ };

871+};

872+var codegenImportToCST = function (v) {

873+ if (v instanceof CodegenImportType) {

874+ if (v.value0) {

875+ return importTypeAll1(v.value1);

876+ };

877+ return importType1(v.value1);

878+ };

879+ if (v instanceof CodegenImportTypeOp) {

880+ return importTypeOp1(v.value0);

881+ };

882+ if (v instanceof CodegenImportClass) {

883+ return importClass1(v.value0);

884+ };

885+ if (v instanceof CodegenImportValue) {

886+ return importValue1(v.value0);

887+ };

888+ if (v instanceof CodegenImportOp) {

889+ return importOp1(v.value0);

890+ };

891+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 380, column 22 - line 387, column 48): " + [ v.constructor.name ]);

892+};

893+var codegenExportToCST = function (v) {

894+ if (v instanceof CodegenExportType) {

895+ if (v.value0) {

896+ return exportTypeAll1(v.value1);

897+ };

898+ return exportType1(v.value1);

899+ };

900+ if (v instanceof CodegenExportTypeOp) {

901+ return exportTypeOp1(v.value0);

902+ };

903+ if (v instanceof CodegenExportClass) {

904+ return exportClass1(v.value0);

905+ };

906+ if (v instanceof CodegenExportValue) {

907+ return exportValue1(v.value0);

908+ };

909+ if (v instanceof CodegenExportOp) {

910+ return exportOp1(v.value0);

911+ };

912+ if (v instanceof CodegenExportModule) {

913+ return exportModule1(v.value0);

914+ };

915+ throw new Error("Failed pattern match at Tidy.Codegen.Monad (line 369, column 22 - line 377, column 56): " + [ v.constructor.name ]);

916+};

917+var moduleFromCodegenState = function (dictToName) {

918+ var module_ = Tidy_Codegen.module_(dictToName);

919+ return function (name) {

920+ return function (st) {

921+ var withLeadingBreaks = (function () {

922+ var $559 = Data_Array.modifyAt(0)(leading(Tidy_Codegen.lineBreaks(2)));

923+ return function ($560) {

924+ return fold($559($560));

925+ };

926+ })();

927+ var importsQualified = bind(toUnfoldable(st.importsQualified))(function (v) {

928+ return bind(toUnfoldable1(v.value1))(function (qual) {

929+ return pure(new Data_Tuple.Tuple(v.value0, declImportAs(v.value0)([ ])(qual)));

930+ });

931+ });

932+ var importsOpen = withLeadingBreaks(map(Data_Function.flip(declImport)([ ]))(fromFoldable(st.importsOpen)));

933+ var importsFrom = bind(toUnfoldable(st.importsFrom))(function (v) {

934+ return pure(new Data_Tuple.Tuple(v.value0, declImport(v.value0)(map(codegenImportToCST)(toUnfoldable1(v.value1)))));

935+ });

936+ var importsNamed = withLeadingBreaks(map((function () {

937+ var $561 = Data_Either.either(identity1)(identity1);

938+ return function ($562) {

939+ return $561(Data_Tuple.snd($562));

940+ };

941+ })())(Data_Array.sortBy(comparing(Data_Tuple.fst))(append(map(map1(Data_Either.Left.create))(importsFrom))(map(map1(Data_Either.Right.create))(importsQualified)))));

942+ var exports = map(codegenExportToCST)(fromFoldable(st.exports));

943+ var decls = fromFoldable1(Data_List.reverse(st.declarations));

944+ return module_(name)(exports)(append(importsOpen)(importsNamed))(decls);

945+ };

946+ };

947+};

948+var runCodegenTModule = function (dictFunctor) {

949+ var map2 = Data_Functor.map(dictFunctor);

950+ return function (dictToName) {

951+ var moduleFromCodegenState1 = moduleFromCodegenState(dictToName);

952+ return function (name) {

953+ var $563 = map2(map1(moduleFromCodegenState1(name)));

954+ return function ($564) {

955+ return $563(runCodegenT($564));

956+ };

957+ };

958+ };

959+};

960+var runCodegenTModule1 = /* #__PURE__ */ runCodegenTModule(Control_Monad_Free.freeFunctor);

961+var codegenModule = function (dictToName) {

962+ var runCodegenTModule2 = runCodegenTModule1(dictToName);

963+ return function (name) {

964+ var $565 = runFree(coerce);

965+ var $566 = runCodegenTModule2(name);

966+ return function ($567) {

967+ return Data_Tuple.snd($565($566($567)));

968+ };

969+ };

970+};

971+export {

972+ CodegenT,

973+ CodegenExportType,

974+ CodegenExportTypeOp,

975+ CodegenExportClass,

976+ CodegenExportValue,

977+ CodegenExportOp,

978+ CodegenExportModule,

979+ CodegenImportType,

980+ CodegenImportTypeOp,

981+ CodegenImportClass,

982+ CodegenImportValue,

983+ CodegenImportOp,

984+ ImportName,

985+ write,

986+ writeAndExport,

987+ exportValue,

988+ exportOp,

989+ exportType,

990+ exportTypeAll,

991+ exportTypeOp,

992+ exportClass,

993+ exportModule,

994+ exporting,

995+ importFrom,

996+ importOpen,

997+ importValue,

998+ importOp,

999+ importType,

1000+ importTypeAll,

1001+ importTypeOp,

1002+ importClass,

1003+ importCtor,

1004+ codegenModule,

1005+ runCodegenT,

1006+ runCodegenTModule,

1007+ moduleFromCodegenState,

1008+ toImportFrom,

1009+ toImportFromRecord,

1010+ eqCodegenExport,

1011+ ordCodegenExport,

1012+ eqCodegenImport,

1013+ ordCodegenImport,

1014+ functorCodegenT,

1015+ applyCodegenT,

1016+ applicativeCodegenT,

1017+ bindCodegenT,

1018+ monadCodegenT,

1019+ monadTransCodegenT,

1020+ monadTellArrayDeclaration,

1021+ monadEffectCodegenT,

1022+ monadSTCodegenT,

1023+ toImportFromImportNameQua,

1024+ toImportFromRecordRecord,

1025+ toImportFromRecordConsRec,

1026+ toImportFromRecordNilReco

1027+};

output-compile-fail/Tidy.Codegen.Precedence/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.Precedence/index.jsnew file+403

@@ -0,0 +1,403 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array from "../Data.Array/index.js";

3+import * as Data_Array_NonEmpty from "../Data.Array.NonEmpty/index.js";

4+import * as Data_Functor from "../Data.Functor/index.js";

5+import * as Data_Maybe from "../Data.Maybe/index.js";

6+import * as PureScript_CST_Types from "../PureScript.CST.Types/index.js";

7+import * as Tidy_Codegen_Common from "../Tidy.Codegen.Common/index.js";

8+var map = /* #__PURE__ */ Data_Functor.map(Data_Functor.functorArray);

9+var map1 = /* #__PURE__ */ Data_Functor.map(Data_Maybe.functorMaybe);

10+var typeParens = /* #__PURE__ */ (function () {

11+ var $220 = Tidy_Codegen_Common.toWrapped(Tidy_Codegen_Common.tokLeftParen)(Tidy_Codegen_Common.tokRightParen);

12+ return function ($221) {

13+ return PureScript_CST_Types.TypeParens.create($220($221));

14+ };

15+})();

16+var precType3 = function (a) {

17+ if (a instanceof PureScript_CST_Types.TypeConstrained) {

18+ return typeParens(a);

19+ };

20+ if (a instanceof PureScript_CST_Types.TypeForall) {

21+ return typeParens(a);

22+ };

23+ if (a instanceof PureScript_CST_Types.TypeArrow) {

24+ return typeParens(a);

25+ };

26+ if (a instanceof PureScript_CST_Types.TypeKinded) {

27+ return typeParens(a);

28+ };

29+ if (a instanceof PureScript_CST_Types.TypeOp) {

30+ return typeParens(a);

31+ };

32+ if (a instanceof PureScript_CST_Types.TypeApp) {

33+ return typeParens(a);

34+ };

35+ return a;

36+};

37+var precType2 = function (a) {

38+ if (a instanceof PureScript_CST_Types.TypeConstrained) {

39+ return typeParens(a);

40+ };

41+ if (a instanceof PureScript_CST_Types.TypeForall) {

42+ return typeParens(a);

43+ };

44+ if (a instanceof PureScript_CST_Types.TypeArrow) {

45+ return typeParens(a);

46+ };

47+ if (a instanceof PureScript_CST_Types.TypeKinded) {

48+ return typeParens(a);

49+ };

50+ if (a instanceof PureScript_CST_Types.TypeOp) {

51+ return typeParens(a);

52+ };

53+ return a;

54+};

55+var precType1 = function (a) {

56+ if (a instanceof PureScript_CST_Types.TypeKinded) {

57+ return typeParens(a);

58+ };

59+ if (a instanceof PureScript_CST_Types.TypeForall) {

60+ return typeParens(a);

61+ };

62+ if (a instanceof PureScript_CST_Types.TypeArrow) {

63+ return typeParens(a);

64+ };

65+ if (a instanceof PureScript_CST_Types.TypeConstrained) {

66+ return typeParens(a);

67+ };

68+ return a;

69+};

70+var precType0 = function (a) {

71+ if (a instanceof PureScript_CST_Types.TypeKinded) {

72+ return typeParens(a);

73+ };

74+ return a;

75+};

76+var precInitLast1 = function (p1) {

77+ return function (p2) {

78+ return function (arr) {

79+ var v = Data_Array_NonEmpty.unsnoc(arr);

80+ return Data_Array_NonEmpty["snoc$prime"](map(p1)(v.init))(p2(v.last));

81+ };

82+ };

83+};

84+var precInitLast = function (p1) {

85+ return function (p2) {

86+ var $222 = map1(function (v) {

87+ return Data_Array_NonEmpty["snoc$prime"](map(p1)(v.init))(p2(v.last));

88+ });

89+ return function ($223) {

90+ return $222(Data_Array.unsnoc($223));

91+ };

92+ };

93+};

94+var exprParens = /* #__PURE__ */ (function () {

95+ var $224 = Tidy_Codegen_Common.toWrapped(Tidy_Codegen_Common.tokLeftParen)(Tidy_Codegen_Common.tokRightParen);

96+ return function ($225) {

97+ return PureScript_CST_Types.ExprParens.create($224($225));

98+ };

99+})();

100+var precExpr0 = function (a) {

101+ if (a instanceof PureScript_CST_Types.ExprTyped) {

102+ return exprParens(a);

103+ };

104+ return a;

105+};

106+var precExpr1 = function (a) {

107+ if (a instanceof PureScript_CST_Types.ExprTyped) {

108+ return exprParens(a);

109+ };

110+ if (a instanceof PureScript_CST_Types.ExprOp) {

111+ return exprParens(a);

112+ };

113+ return a;

114+};

115+var precExpr2 = function (a) {

116+ if (a instanceof PureScript_CST_Types.ExprTyped) {

117+ return exprParens(a);

118+ };

119+ if (a instanceof PureScript_CST_Types.ExprOp) {

120+ return exprParens(a);

121+ };

122+ if (a instanceof PureScript_CST_Types.ExprLambda) {

123+ return exprParens(a);

124+ };

125+ if (a instanceof PureScript_CST_Types.ExprIf) {

126+ return exprParens(a);

127+ };

128+ if (a instanceof PureScript_CST_Types.ExprLet) {

129+ return exprParens(a);

130+ };

131+ if (a instanceof PureScript_CST_Types.ExprAdo) {

132+ return exprParens(a);

133+ };

134+ return a;

135+};

136+var precExpr3 = function (a) {

137+ if (a instanceof PureScript_CST_Types.ExprTyped) {

138+ return exprParens(a);

139+ };

140+ if (a instanceof PureScript_CST_Types.ExprOp) {

141+ return exprParens(a);

142+ };

143+ if (a instanceof PureScript_CST_Types.ExprLambda) {

144+ return exprParens(a);

145+ };

146+ if (a instanceof PureScript_CST_Types.ExprIf) {

147+ return exprParens(a);

148+ };

149+ if (a instanceof PureScript_CST_Types.ExprLet) {

150+ return exprParens(a);

151+ };

152+ if (a instanceof PureScript_CST_Types.ExprAdo) {

153+ return exprParens(a);

154+ };

155+ if (a instanceof PureScript_CST_Types.ExprInfix) {

156+ return exprParens(a);

157+ };

158+ return a;

159+};

160+var precExpr4 = function (a) {

161+ if (a instanceof PureScript_CST_Types.ExprTyped) {

162+ return exprParens(a);

163+ };

164+ if (a instanceof PureScript_CST_Types.ExprOp) {

165+ return exprParens(a);

166+ };

167+ if (a instanceof PureScript_CST_Types.ExprLambda) {

168+ return exprParens(a);

169+ };

170+ if (a instanceof PureScript_CST_Types.ExprIf) {

171+ return exprParens(a);

172+ };

173+ if (a instanceof PureScript_CST_Types.ExprLet) {

174+ return exprParens(a);

175+ };

176+ if (a instanceof PureScript_CST_Types.ExprAdo) {

177+ return exprParens(a);

178+ };

179+ if (a instanceof PureScript_CST_Types.ExprInfix) {

180+ return exprParens(a);

181+ };

182+ if (a instanceof PureScript_CST_Types.ExprCase) {

183+ return exprParens(a);

184+ };

185+ if (a instanceof PureScript_CST_Types.ExprDo) {

186+ return exprParens(a);

187+ };

188+ return a;

189+};

190+var precExpr5 = function (a) {

191+ if (a instanceof PureScript_CST_Types.ExprTyped) {

192+ return exprParens(a);

193+ };

194+ if (a instanceof PureScript_CST_Types.ExprOp) {

195+ return exprParens(a);

196+ };

197+ if (a instanceof PureScript_CST_Types.ExprInfix) {

198+ return exprParens(a);

199+ };

200+ if (a instanceof PureScript_CST_Types.ExprNegate) {

201+ return exprParens(a);

202+ };

203+ if (a instanceof PureScript_CST_Types.ExprApp) {

204+ return exprParens(a);

205+ };

206+ return a;

207+};

208+var precExpr6 = function (a) {

209+ if (a instanceof PureScript_CST_Types.ExprTyped) {

210+ return exprParens(a);

211+ };

212+ if (a instanceof PureScript_CST_Types.ExprOp) {

213+ return exprParens(a);

214+ };

215+ if (a instanceof PureScript_CST_Types.ExprInfix) {

216+ return exprParens(a);

217+ };

218+ if (a instanceof PureScript_CST_Types.ExprNegate) {

219+ return exprParens(a);

220+ };

221+ if (a instanceof PureScript_CST_Types.ExprApp) {

222+ return exprParens(a);

223+ };

224+ if (a instanceof PureScript_CST_Types.ExprLambda) {

225+ return exprParens(a);

226+ };

227+ if (a instanceof PureScript_CST_Types.ExprIf) {

228+ return exprParens(a);

229+ };

230+ if (a instanceof PureScript_CST_Types.ExprCase) {

231+ return exprParens(a);

232+ };

233+ if (a instanceof PureScript_CST_Types.ExprLet) {

234+ return exprParens(a);

235+ };

236+ if (a instanceof PureScript_CST_Types.ExprDo) {

237+ return exprParens(a);

238+ };

239+ if (a instanceof PureScript_CST_Types.ExprAdo) {

240+ return exprParens(a);

241+ };

242+ return a;

243+};

244+var precExpr7 = function (a) {

245+ if (a instanceof PureScript_CST_Types.ExprTyped) {

246+ return exprParens(a);

247+ };

248+ if (a instanceof PureScript_CST_Types.ExprOp) {

249+ return exprParens(a);

250+ };

251+ if (a instanceof PureScript_CST_Types.ExprInfix) {

252+ return exprParens(a);

253+ };

254+ if (a instanceof PureScript_CST_Types.ExprNegate) {

255+ return exprParens(a);

256+ };

257+ if (a instanceof PureScript_CST_Types.ExprApp) {

258+ return exprParens(a);

259+ };

260+ if (a instanceof PureScript_CST_Types.ExprLambda) {

261+ return exprParens(a);

262+ };

263+ if (a instanceof PureScript_CST_Types.ExprIf) {

264+ return exprParens(a);

265+ };

266+ if (a instanceof PureScript_CST_Types.ExprCase) {

267+ return exprParens(a);

268+ };

269+ if (a instanceof PureScript_CST_Types.ExprLet) {

270+ return exprParens(a);

271+ };

272+ if (a instanceof PureScript_CST_Types.ExprDo) {

273+ return exprParens(a);

274+ };

275+ if (a instanceof PureScript_CST_Types.ExprAdo) {

276+ return exprParens(a);

277+ };

278+ if (a instanceof PureScript_CST_Types.ExprRecordAccessor) {

279+ return exprParens(a);

280+ };

281+ if (a instanceof PureScript_CST_Types.ExprRecordUpdate) {

282+ return exprParens(a);

283+ };

284+ return a;

285+};

286+var precExprApp = function (a) {

287+ if (a instanceof PureScript_CST_Types.ExprTyped) {

288+ return exprParens(a);

289+ };

290+ if (a instanceof PureScript_CST_Types.ExprOp) {

291+ return exprParens(a);

292+ };

293+ if (a instanceof PureScript_CST_Types.ExprLambda) {

294+ return exprParens(a);

295+ };

296+ if (a instanceof PureScript_CST_Types.ExprIf) {

297+ return exprParens(a);

298+ };

299+ if (a instanceof PureScript_CST_Types.ExprLet) {

300+ return exprParens(a);

301+ };

302+ if (a instanceof PureScript_CST_Types.ExprAdo) {

303+ return exprParens(a);

304+ };

305+ if (a instanceof PureScript_CST_Types.ExprInfix) {

306+ return exprParens(a);

307+ };

308+ if (a instanceof PureScript_CST_Types.ExprApp) {

309+ return exprParens(a);

310+ };

311+ return a;

312+};

313+var precExprAppLast = function (a) {

314+ if (a instanceof PureScript_CST_Types.ExprTyped) {

315+ return exprParens(a);

316+ };

317+ if (a instanceof PureScript_CST_Types.ExprOp) {

318+ return exprParens(a);

319+ };

320+ if (a instanceof PureScript_CST_Types.ExprInfix) {

321+ return exprParens(a);

322+ };

323+ if (a instanceof PureScript_CST_Types.ExprApp) {

324+ return exprParens(a);

325+ };

326+ return a;

327+};

328+var precExprInfix = function (a) {

329+ if (a instanceof PureScript_CST_Types.ExprTyped) {

330+ return exprParens(a);

331+ };

332+ if (a instanceof PureScript_CST_Types.ExprOp) {

333+ return exprParens(a);

334+ };

335+ if (a instanceof PureScript_CST_Types.ExprInfix) {

336+ return exprParens(a);

337+ };

338+ return a;

339+};

340+var binderParens = /* #__PURE__ */ (function () {

341+ var $226 = Tidy_Codegen_Common.toWrapped(Tidy_Codegen_Common.tokLeftParen)(Tidy_Codegen_Common.tokRightParen);

342+ return function ($227) {

343+ return PureScript_CST_Types.BinderParens.create($226($227));

344+ };

345+})();

346+var precBinder0 = function (a) {

347+ if (a instanceof PureScript_CST_Types.BinderTyped) {

348+ return binderParens(a);

349+ };

350+ return a;

351+};

352+var precBinder1 = function (a) {

353+ if (a instanceof PureScript_CST_Types.BinderTyped) {

354+ return binderParens(a);

355+ };

356+ if (a instanceof PureScript_CST_Types.BinderOp) {

357+ return binderParens(a);

358+ };

359+ return a;

360+};

361+var precBinder2 = function (a) {

362+ if (a instanceof PureScript_CST_Types.BinderTyped) {

363+ return binderParens(a);

364+ };

365+ if (a instanceof PureScript_CST_Types.BinderOp) {

366+ return binderParens(a);

367+ };

368+ if (a instanceof PureScript_CST_Types.BinderInt && a.value0 instanceof Data_Maybe.Just) {

369+ return binderParens(a);

370+ };

371+ if (a instanceof PureScript_CST_Types.BinderNumber && a.value0 instanceof Data_Maybe.Just) {

372+ return binderParens(a);

373+ };

374+ if (a instanceof PureScript_CST_Types.BinderConstructor && !Data_Array["null"](a.value1)) {

375+ return binderParens(a);

376+ };

377+ return a;

378+};

379+export {

380+ typeParens,

381+ precType0,

382+ precType1,

383+ precType2,

384+ precType3,

385+ exprParens,

386+ precExpr0,

387+ precExpr1,

388+ precExprInfix,

389+ precExpr2,

390+ precExpr3,

391+ precExprApp,

392+ precExprAppLast,

393+ precExpr4,

394+ precExpr5,

395+ precExpr6,

396+ precExpr7,

397+ binderParens,

398+ precBinder0,

399+ precBinder1,

400+ precBinder2,

401+ precInitLast,

402+ precInitLast1

403+};

output-compile-fail/Tidy.Codegen.String/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.String/index.jsnew file+62

@@ -0,0 +1,62 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Array from "../Data.Array/index.js";

3+import * as Data_Boolean from "../Data.Boolean/index.js";

4+import * as Data_CodePoint_Unicode from "../Data.CodePoint.Unicode/index.js";

5+import * as Data_Enum from "../Data.Enum/index.js";

6+import * as Data_Eq from "../Data.Eq/index.js";

7+import * as Data_Foldable from "../Data.Foldable/index.js";

8+import * as Data_Function from "../Data.Function/index.js";

9+import * as Data_Int from "../Data.Int/index.js";

10+import * as Data_Maybe from "../Data.Maybe/index.js";

11+import * as Data_Monoid from "../Data.Monoid/index.js";

12+import * as Data_Set from "../Data.Set/index.js";

13+import * as Data_String_CodePoints from "../Data.String.CodePoints/index.js";

14+import * as Data_String_CodeUnits from "../Data.String.CodeUnits/index.js";

15+import * as Tidy_Codegen_Types from "../Tidy.Codegen.Types/index.js";

16+var fromEnum = /* #__PURE__ */ Data_Enum.fromEnum(Data_String_CodePoints.boundedEnumCodePoint);

17+var power = /* #__PURE__ */ Data_Monoid.power(Data_Monoid.monoidString);

18+var eq = /* #__PURE__ */ Data_Eq.eq(Data_String_CodePoints.eqCodePoint);

19+var escapeSourceString = /* #__PURE__ */ (function () {

20+ var toHex = function (cp) {

21+ var hex = Data_Int.toStringAs(Data_Int.hexadecimal)(fromEnum(cp));

22+ return power("0")(6 - Data_String_CodeUnits.length(hex) | 0) + hex;

23+ };

24+ var categories = Data_Set.fromFoldable(Data_Foldable.foldableArray)(Data_CodePoint_Unicode.ordGeneralCategory)([ Data_CodePoint_Unicode.UppercaseLetter.value, Data_CodePoint_Unicode.LowercaseLetter.value, Data_CodePoint_Unicode.TitlecaseLetter.value, Data_CodePoint_Unicode.OtherLetter.value, Data_CodePoint_Unicode.DecimalNumber.value, Data_CodePoint_Unicode.LetterNumber.value, Data_CodePoint_Unicode.OtherNumber.value, Data_CodePoint_Unicode.ConnectorPunctuation.value, Data_CodePoint_Unicode.DashPunctuation.value, Data_CodePoint_Unicode.OpenPunctuation.value, Data_CodePoint_Unicode.ClosePunctuation.value, Data_CodePoint_Unicode.InitialQuote.value, Data_CodePoint_Unicode.FinalQuote.value, Data_CodePoint_Unicode.OtherPunctuation.value, Data_CodePoint_Unicode.MathSymbol.value, Data_CodePoint_Unicode.CurrencySymbol.value, Data_CodePoint_Unicode.ModifierSymbol.value, Data_CodePoint_Unicode.OtherSymbol.value, Data_CodePoint_Unicode.Space.value ]);

25+ var shouldPrint = (function () {

26+ var $11 = Data_Maybe.maybe(false)(Data_Function.flip(Data_Set.member(Data_CodePoint_Unicode.ordGeneralCategory))(categories));

27+ return function ($12) {

28+ return $11(Data_CodePoint_Unicode.generalCategory($12));

29+ };

30+ })();

31+ var $$escape = function (cp) {

32+ if (eq(cp)(Data_String_CodePoints.codePointFromChar("\x0a"))) {

33+ return "\\n";

34+ };

35+ if (eq(cp)(Data_String_CodePoints.codePointFromChar("\x0d"))) {

36+ return "\\r";

37+ };

38+ if (eq(cp)(Data_String_CodePoints.codePointFromChar("\x09"))) {

39+ return "\\t";

40+ };

41+ if (eq(cp)(Data_String_CodePoints.codePointFromChar("\\"))) {

42+ return "\\\\";

43+ };

44+ if (eq(cp)(Data_String_CodePoints.codePointFromChar("\""))) {

45+ return "\\\"";

46+ };

47+ if (shouldPrint(cp)) {

48+ return Data_String_CodePoints.singleton(cp);

49+ };

50+ if (Data_Boolean.otherwise) {

51+ return "\\x" + toHex(cp);

52+ };

53+ throw new Error("Failed pattern match at Tidy.Codegen.String (line 21, column 3 - line 21, column 32): " + [ cp.constructor.name ]);

54+ };

55+ var $13 = Data_Array.foldMap(Data_Monoid.monoidString)($$escape);

56+ return function ($14) {

57+ return Tidy_Codegen_Types.SourceString($13(Data_String_CodePoints.toCodePointArray($14)));

58+ };

59+})();

60+export {

61+ escapeSourceString

62+};

output-compile-fail/Tidy.Codegen.Types/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen.Types/index.jsnew file+78

@@ -0,0 +1,78 @@

1+// Generated by purs version 0.15.15

2+import * as Data_Eq from "../Data.Eq/index.js";

3+import * as Data_Ord from "../Data.Ord/index.js";

4+import * as Data_Tuple from "../Data.Tuple/index.js";

5+var SymbolName = function (x) {

6+ return x;

7+};

8+var SourceString = function (x) {

9+ return x;

10+};

11+var Qualified = /* #__PURE__ */ (function () {

12+ function Qualified(value0, value1) {

13+ this.value0 = value0;

14+ this.value1 = value1;

15+ };

16+ Qualified.create = function (value0) {

17+ return function (value1) {

18+ return new Qualified(value0, value1);

19+ };

20+ };

21+ return Qualified;

22+})();

23+var GuardedBranch = /* #__PURE__ */ (function () {

24+ function GuardedBranch(value0, value1) {

25+ this.value0 = value0;

26+ this.value1 = value1;

27+ };

28+ GuardedBranch.create = function (value0) {

29+ return function (value1) {

30+ return new GuardedBranch(value0, value1);

31+ };

32+ };

33+ return GuardedBranch;

34+})();

35+var BinaryOp = function (x) {

36+ return x;

37+};

38+var ordSymbolName = Data_Ord.ordString;

39+var ordSourceString = Data_Ord.ordString;

40+var newtypeSymbolName_ = {

41+ Coercible0: function () {

42+ return undefined;

43+ }

44+};

45+var newtypeSourceString_ = {

46+ Coercible0: function () {

47+ return undefined;

48+ }

49+};

50+var functorQualified = {

51+ map: function (f) {

52+ return function (m) {

53+ return new Qualified(m.value0, f(m.value1));

54+ };

55+ }

56+};

57+var functorBinaryOp = Data_Tuple.functorTuple;

58+var eqSymbolName = Data_Eq.eqString;

59+var eqSourceString = Data_Eq.eqString;

60+var unQualified = function (v) {

61+ return v.value1;

62+};

63+export {

64+ SymbolName,

65+ Qualified,

66+ unQualified,

67+ BinaryOp,

68+ GuardedBranch,

69+ SourceString,

70+ newtypeSymbolName_,

71+ eqSymbolName,

72+ ordSymbolName,

73+ functorQualified,

74+ functorBinaryOp,

75+ newtypeSourceString_,

76+ eqSourceString,

77+ ordSourceString

78+};

output-compile-fail/Tidy.Codegen/externs.cbornew file

Binary file not shown.

output-compile-fail/Tidy.Codegen/index.jsnew file+1563