c8b6714 · rowtype-yoga/purescript-native

69 (:) = cons

70

71 foreign import cons

72+ """

72− "function cons(e) {\

73+ function cons(e) {

73− \ return function(l) {\

74+ return function(l) {

74− \ return [e].concat(l);\

75+ return [e].concat(l);

75− \ };\

76+ };

77+ }

76− \}" :: forall a. a -> [a] -> [a]

78+ """ :: forall a. a -> [a] -> [a]

77

79

78 class Show a where

80 class Show a where

79 show :: a -> String

81 show :: a -> String

80

82

81 foreign import showStringImpl

83 foreign import showStringImpl

84+ """

82− "function showStringImpl(s) {\

85+ function showStringImpl(s) {

83− \ return JSON.stringify(s);\

86+ return JSON.stringify(s);

87+ }

84− \}" :: String -> String

88+ """ :: String -> String

85

89

86 instance showUnit :: Show Unit where

90 instance showUnit :: Show Unit where

87 show (Unit {}) = "Unit {}"

91 show (Unit {}) = "Unit {}"

93 show true = "true"

97 show true = "true"

94 show false = "false"

98 show false = "false"

95

99

96− foreign import showNumberImpl "function showNumberImpl(n) {\

100+ foreign import showNumberImpl

101+ """

102+ function showNumberImpl(n) {

97− \ return n.toString();\

103+ return n.toString();

104+ }

98− \}" :: Number -> String

105+ """ :: Number -> String

99

106

100 instance showNumber :: Show Number where

107 instance showNumber :: Show Number where

101 show = showNumberImpl

108 show = showNumberImpl

102

109

103 foreign import showArrayImpl

110 foreign import showArrayImpl

111+ """

104− "function showArrayImpl(f) {\

112+ function showArrayImpl(f) {

105− \ return function(xs) {\

113+ return function(xs) {

106− \ var ss = [];\

114+ var ss = [];

107− \ for (var i = 0, l = xs.length; i < l; i++) {\

115+ for (var i = 0, l = xs.length; i < l; i++) {

108− \ ss[i] = f(xs[i]);\

116+ ss[i] = f(xs[i]);

109− \ }\

117+ }

110− \ return '[' + ss.join(',') + ']';\

118+ return '[' + ss.join(',') + ']';

111− \ };\

119+ };

120+ }

112− \}" :: forall a. (a -> String) -> [a] -> String

121+ """ :: forall a. (a -> String) -> [a] -> String

113

122

114 instance showArray :: (Show a) => Show [a] where

123 instance showArray :: (Show a) => Show [a] where

115 show = showArrayImpl show

124 show = showArrayImpl show

187 (%) :: a -> a -> a

196 (%) :: a -> a -> a

188 negate :: a -> a

197 negate :: a -> a

189

198

190− foreign import numAdd "function numAdd(n1) {\

199+ foreign import numAdd

200+ """

201+ function numAdd(n1) {

191− \ return function(n2) {\

202+ return function(n2) {

192− \ return n1 + n2;\

203+ return n1 + n2;

193− \ };\

204+ };

205+ }

194− \}" :: Number -> Number -> Number

206+ """ :: Number -> Number -> Number

195−

207+

196− foreign import numSub "function numSub(n1) {\

208+ foreign import numSub

209+ """

210+ function numSub(n1) {

197− \ return function(n2) {\

211+ return function(n2) {

198− \ return n1 - n2;\

212+ return n1 - n2;

199− \ };\

213+ };

214+ }

200− \}" :: Number -> Number -> Number

215+ """ :: Number -> Number -> Number

201−

216+

202− foreign import numMul "function numMul(n1) {\

217+ foreign import numMul

218+ """

219+ function numMul(n1) {

203− \ return function(n2) {\

220+ return function(n2) {

204− \ return n1 * n2;\

221+ return n1 * n2;

205− \ };\

222+ };

223+ }

206− \}" :: Number -> Number -> Number

224+ """ :: Number -> Number -> Number

207−

225+

208− foreign import numDiv "function numDiv(n1) {\

226+ foreign import numDiv

227+ """

228+ function numDiv(n1) {

209− \ return function(n2) {\

229+ return function(n2) {

210− \ return n1 / n2;\

230+ return n1 / n2;

211− \ };\

231+ };

232+ }

212− \}" :: Number -> Number -> Number

233+ """ :: Number -> Number -> Number

213−

234+

214− foreign import numMod "function numMod(n1) {\

235+ foreign import numMod

236+ """

237+ function numMod(n1) {

215− \ return function(n2) {\

238+ return function(n2) {

216− \ return n1 % n2;\

239+ return n1 % n2;

217− \ };\

240+ };

241+ }

218− \}" :: Number -> Number -> Number

242+ """ :: Number -> Number -> Number

219−

243+

220− foreign import numNegate "function numNegate(n) {\

244+ foreign import numNegate

245+ """

246+ function numNegate(n) {

221− \ return -n;\

247+ return -n;

248+ }

222− \}" :: Number -> Number

249+ """ :: Number -> Number

223

250

224 instance numNumber :: Num Number where

251 instance numNumber :: Num Number where

225 (+) = numAdd

252 (+) = numAdd

242 (/=) :: a -> a -> Boolean

269 (/=) :: a -> a -> Boolean

243

270

244 foreign import refEq

271 foreign import refEq

272+ """

245− "function refEq(r1) {\

273+ function refEq(r1) {

246− \ return function(r2) {\

274+ return function(r2) {

247− \ return r1 === r2;\

275+ return r1 === r2;

248− \ };\

276+ };

277+ }

249− \}" :: forall a. a -> a -> Boolean

278+ """ :: forall a. a -> a -> Boolean

250

279

251 foreign import refIneq

280 foreign import refIneq

281+ """

252− "function refIneq(r1) {\

282+ function refIneq(r1) {

253− \ return function(r2) {\

283+ return function(r2) {

254− \ return r1 !== r2;\

284+ return r1 !== r2;

255− \ };\

285+ };

286+ }

256− \}" :: forall a. a -> a -> Boolean

287+ """ :: forall a. a -> a -> Boolean

257

288

258 instance eqUnit :: Eq Unit where

289 instance eqUnit :: Eq Unit where

259 (==) (Unit {}) (Unit {}) = true

290 (==) (Unit {}) (Unit {}) = true

272 (/=) = refIneq

303 (/=) = refIneq

273

304

274 foreign import eqArrayImpl

305 foreign import eqArrayImpl

306+ """

275− "function eqArrayImpl(f) {\

307+ function eqArrayImpl(f) {

276− \ return function(xs) {\

308+ return function(xs) {

277− \ return function(ys) {\

309+ return function(ys) {

278− \ if (xs.length !== ys.length) return false;\

310+ if (xs.length !== ys.length) return false;

279− \ for (var i = 0; i < xs.length; i++) {\

311+ for (var i = 0; i < xs.length; i++) {

280− \ if (!f(xs[i])(ys[i])) return false;\

312+ if (!f(xs[i])(ys[i])) return false;

281− \ }\

313+ }

282− \ return true;\

314+ return true;

283− \ };\

315+ };

284− \ };\

316+ };

317+ }

285− \}" :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> Boolean

318+ """ :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> Boolean

286

319

287 instance eqArray :: (Eq a) => Eq [a] where

320 instance eqArray :: (Eq a) => Eq [a] where

288 (==) xs ys = eqArrayImpl (==) xs ys

321 (==) xs ys = eqArrayImpl (==) xs ys

334 _ -> true

367 _ -> true

335

368

336 foreign import unsafeCompareImpl

369 foreign import unsafeCompareImpl

370+ """

337− "function unsafeCompareImpl(lt) {\

371+ function unsafeCompareImpl(lt) {

338− \ return function(eq) {\

372+ return function(eq) {

339− \ return function(gt) {\

373+ return function(gt) {

340− \ return function(x) {\

374+ return function(x) {

341− \ return function(y) {\

375+ return function(y) {

342− \ return x < y ? lt : x > y ? gt : eq;\

376+ return x < y ? lt : x > y ? gt : eq;

343− \ };\

377+ };

344− \ };\

378+ };

345− \ };\

379+ };

346− \ };\

380+ };

381+ }

347− \}" :: forall a. Ordering -> Ordering -> Ordering -> a -> a -> Ordering

382+ """ :: forall a. Ordering -> Ordering -> Ordering -> a -> a -> Ordering

348

383

349 unsafeCompare :: forall a. a -> a -> Ordering

384 unsafeCompare :: forall a. a -> a -> Ordering

350 unsafeCompare = unsafeCompareImpl LT EQ GT

385 unsafeCompare = unsafeCompareImpl LT EQ GT

385 zshr :: b -> Number -> b

420 zshr :: b -> Number -> b

386 complement :: b -> b

421 complement :: b -> b

387

422

388− foreign import numShl "function numShl(n1) {\

423+ foreign import numShl

424+ """

425+ function numShl(n1) {

389− \ return function(n2) {\

426+ return function(n2) {

390− \ return n1 << n2;\

427+ return n1 << n2;

391− \ };\

428+ };

429+ }

392− \}" :: Number -> Number -> Number

430+ """ :: Number -> Number -> Number

393−

431+

394− foreign import numShr "function numShr(n1) {\

432+ foreign import numShr

433+ """

434+ function numShr(n1) {

395− \ return function(n2) {\

435+ return function(n2) {

396− \ return n1 >> n2;\

436+ return n1 >> n2;

397− \ };\

437+ };

438+ }

398− \}" :: Number -> Number -> Number

439+ """ :: Number -> Number -> Number

399−

440+

400− foreign import numZshr "function numZshr(n1) {\

441+ foreign import numZshr

442+ """

443+ function numZshr(n1) {

401− \ return function(n2) {\

444+ return function(n2) {

402− \ return n1 >>> n2;\

445+ return n1 >>> n2;

403− \ };\

446+ };

447+ }

404− \}" :: Number -> Number -> Number

448+ """ :: Number -> Number -> Number

405−

449+

406− foreign import numAnd "function numAnd(n1) {\

450+ foreign import numAnd

451+ """

452+ function numAnd(n1) {

407− \ return function(n2) {\

453+ return function(n2) {

408− \ return n1 & n2;\

454+ return n1 & n2;

409− \ };\

455+ };

456+ }

410− \}" :: Number -> Number -> Number

457+ """ :: Number -> Number -> Number

411−

458+

412− foreign import numOr "function numOr(n1) {\

459+ foreign import numOr

460+ """

461+ function numOr(n1) {

413− \ return function(n2) {\

462+ return function(n2) {

414− \ return n1 | n2;\

463+ return n1 | n2;

415− \ };\

464+ };

465+ }

416− \}" :: Number -> Number -> Number

466+ """ :: Number -> Number -> Number

417−

467+

418− foreign import numXor "function numXor(n1) {\

468+ foreign import numXor

469+ """

470+ function numXor(n1) {

419− \ return function(n2) {\

471+ return function(n2) {

420− \ return n1 ^ n2;\

472+ return n1 ^ n2;

421− \ };\

473+ };

474+ }

422− \}" :: Number -> Number -> Number

475+ """ :: Number -> Number -> Number

423−

476+

424− foreign import numComplement "function numComplement(n) {\

477+ foreign import numComplement

478+ """

479+ function numComplement(n) {

425− \ return ~n;\

480+ return ~n;

481+ }

426− \}" :: Number -> Number

482+ """ :: Number -> Number

427

483

428 instance bitsNumber :: Bits Number where

484 instance bitsNumber :: Bits Number where

429 (.&.) = numAnd

485 (.&.) = numAnd

442 (||) :: b -> b -> b

498 (||) :: b -> b -> b

443 not :: b -> b

499 not :: b -> b

444

500

445− foreign import boolAnd "function boolAnd(b1) {\

501+ foreign import boolAnd

502+ """

503+ function boolAnd(b1) {

446− \ return function(b2) {\

504+ return function(b2) {

447− \ return b1 && b2;\

505+ return b1 && b2;

448− \ };\

506+ };

507+ }

449− \}" :: Boolean -> Boolean -> Boolean

508+ """ :: Boolean -> Boolean -> Boolean

450−

509+

451− foreign import boolOr "function boolOr(b1) {\

510+ foreign import boolOr

511+ """

512+ function boolOr(b1) {

452− \ return function(b2) {\

513+ return function(b2) {

453− \ return b1 || b2;\

514+ return b1 || b2;

454− \ };\

515+ };

516+ }

455− \}" :: Boolean -> Boolean -> Boolean

517+ """ :: Boolean -> Boolean -> Boolean

456−

518+

457− foreign import boolNot "function boolNot(b) {\

519+ foreign import boolNot

520+ """

521+ function boolNot(b) {

458− \ return !b;\

522+ return !b;

523+ }

459− \}" :: Boolean -> Boolean

524+ """ :: Boolean -> Boolean

460

525

461 instance boolLikeBoolean :: BoolLike Boolean where

526 instance boolLikeBoolean :: BoolLike Boolean where

462 (&&) = boolAnd

527 (&&) = boolAnd

469 (<>) :: a -> a -> a

534 (<>) :: a -> a -> a

470

535

471 foreign import concatString

536 foreign import concatString

537+ """

472− "function concatString(s1) {\

538+ function concatString(s1) {

473− \ return function(s2) {\

539+ return function(s2) {

474− \ return s1 + s2;\

540+ return s1 + s2;

475− \ };\

541+ };

542+ }

476− \}" :: String -> String -> String

543+ """ :: String -> String -> String

477

544

478 instance semigroupUnit :: Semigroup Unit where

545 instance semigroupUnit :: Semigroup Unit where

479 (<>) (Unit {}) (Unit {}) = Unit {}

546 (<>) (Unit {}) (Unit {}) = Unit {}

507 foreign import data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *

574 foreign import data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *

508

575

509 foreign import mkFn0

576 foreign import mkFn0

577+ """

510− "function mkFn0(fn) {\

578+ function mkFn0(fn) {

511− \ return function() {\

579+ return function() {

512− \ return fn({});\

580+ return fn({});

513− \ };\

581+ };

582+ }

514− \}" :: forall a. (Unit -> a) -> Fn0 a

583+ """ :: forall a. (Unit -> a) -> Fn0 a

515

584

516 foreign import mkFn1

585 foreign import mkFn1

586+ """

517− "function mkFn1(fn) {\

587+ function mkFn1(fn) {

518− \ return function(a) {\

588+ return function(a) {

519− \ return fn(a);\

589+ return fn(a);

520− \ };\

590+ };

591+ }

521− \}" :: forall a b. (a -> b) -> Fn1 a b

592+ """ :: forall a b. (a -> b) -> Fn1 a b

522

593

523 foreign import mkFn2

594 foreign import mkFn2

595+ """

524− "function mkFn2(fn) {\

596+ function mkFn2(fn) {

525− \ return function(a, b) {\

597+ return function(a, b) {

526− \ return fn(a)(b);\

598+ return fn(a)(b);

527− \ };\

599+ };

600+ }

528− \}" :: forall a b c. (a -> b -> c) -> Fn2 a b c

601+ """ :: forall a b c. (a -> b -> c) -> Fn2 a b c

529

602

530 foreign import mkFn3

603 foreign import mkFn3

604+ """

531− "function mkFn3(fn) {\

605+ function mkFn3(fn) {

532− \ return function(a, b, c) {\

606+ return function(a, b, c) {

533− \ return fn(a)(b)(c);\

607+ return fn(a)(b)(c);

534− \ };\

608+ };

609+ }

535− \}" :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d

610+ """ :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d

536

611

537 foreign import mkFn4

612 foreign import mkFn4

613+ """

538− "function mkFn4(fn) {\

614+ function mkFn4(fn) {

539− \ return function(a, b, c, d) {\

615+ return function(a, b, c, d) {

540− \ return fn(a)(b)(c)(d);\

616+ return fn(a)(b)(c)(d);

541− \ };\

617+ };

618+ }

542− \}" :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e

619+ """ :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e

543

620

544 foreign import mkFn5

621 foreign import mkFn5

622+ """

545− "function mkFn5(fn) {\

623+ function mkFn5(fn) {

546− \ return function(a, b, c, d, e) {\

624+ return function(a, b, c, d, e) {

547− \ return fn(a)(b)(c)(d)(e);\

625+ return fn(a)(b)(c)(d)(e);

548− \ };\

626+ };

627+ }

549− \}" :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f

628+ """ :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f

550

629

551 foreign import mkFn6

630 foreign import mkFn6

631+ """

552− "function mkFn6(fn) {\

632+ function mkFn6(fn) {

553− \ return function(a, b, c, d, e, f) {\

633+ return function(a, b, c, d, e, f) {

554− \ return fn(a)(b)(c)(d)(e)(f);\

634+ return fn(a)(b)(c)(d)(e)(f);

555− \ };\

635+ };

636+ }

556− \}" :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g

637+ """ :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g

557

638

558 foreign import mkFn7

639 foreign import mkFn7

640+ """

559− "function mkFn7(fn) {\

641+ function mkFn7(fn) {

560− \ return function(a, b, c, d, e, f, g) {\

642+ return function(a, b, c, d, e, f, g) {

561− \ return fn(a)(b)(c)(d)(e)(f)(g);\

643+ return fn(a)(b)(c)(d)(e)(f)(g);

562− \ };\

644+ };

645+ }

563− \}" :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h

646+ """ :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h

564

647

565 foreign import mkFn8

648 foreign import mkFn8

649+ """

566− "function mkFn8(fn) {\

650+ function mkFn8(fn) {

567− \ return function(a, b, c, d, e, f, g, h) {\

651+ return function(a, b, c, d, e, f, g, h) {

568− \ return fn(a)(b)(c)(d)(e)(f)(g)(h);\

652+ return fn(a)(b)(c)(d)(e)(f)(g)(h);

569− \ };\

653+ };

654+ }

570− \}" :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i

655+ """ :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i

571

656

572 foreign import mkFn9

657 foreign import mkFn9

658+ """

573− "function mkFn9(fn) {\

659+ function mkFn9(fn) {

574− \ return function(a, b, c, d, e, f, g, h, i) {\

660+ return function(a, b, c, d, e, f, g, h, i) {

575− \ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);\

661+ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);

576− \ };\

662+ };

663+ }

577− \}" :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j

664+ """ :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j

578

665

579 foreign import mkFn10

666 foreign import mkFn10

667+ """

580− "function mkFn10(fn) {\

668+ function mkFn10(fn) {

581− \ return function(a, b, c, d, e, f, g, h, i, j) {\

669+ return function(a, b, c, d, e, f, g, h, i, j) {

582− \ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);\

670+ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);

583− \ };\

671+ };

672+ }

584− \}" :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k

673+ """ :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k

585

674

586 foreign import runFn0

675 foreign import runFn0

676+ """

587− "function runFn0(fn) {\

677+ function runFn0(fn) {

588− \ return fn();\

678+ return fn();

679+ }

589− \}" :: forall a. Fn0 a -> a

680+ """ :: forall a. Fn0 a -> a

590

681

591 foreign import runFn1

682 foreign import runFn1

683+ """

592− "function runFn1(fn) {\

684+ function runFn1(fn) {

593− \ return function(a) {\

685+ return function(a) {

594− \ return fn(a);\

686+ return fn(a);

595− \ };\

687+ };

688+ }

596− \}" :: forall a b. Fn1 a b -> a -> b

689+ """ :: forall a b. Fn1 a b -> a -> b

597

690

598 foreign import runFn2

691 foreign import runFn2

692+ """

599− "function runFn2(fn) {\

693+ function runFn2(fn) {

600− \ return function(a) {\

694+ return function(a) {

601− \ return function(b) {\

695+ return function(b) {

602− \ return fn(a, b);\

696+ return fn(a, b);

603− \ };\

697+ };

604− \ };\

698+ };

699+ }

605− \}" :: forall a b c. Fn2 a b c -> a -> b -> c

700+ """ :: forall a b c. Fn2 a b c -> a -> b -> c

606

701

607 foreign import runFn3

702 foreign import runFn3

703+ """

608− "function runFn3(fn) {\

704+ function runFn3(fn) {

609− \ return function(a) {\

705+ return function(a) {

610− \ return function(b) {\

706+ return function(b) {

611− \ return function(c) {\

707+ return function(c) {

612− \ return fn(a, b, c);\

708+ return fn(a, b, c);

613− \ };\

709+ };

614− \ };\

710+ };

615− \ };\

711+ };

712+ }

616− \}" :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d

713+ """ :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d

617

714

618 foreign import runFn4

715 foreign import runFn4

716+ """

619− "function runFn4(fn) {\

717+ function runFn4(fn) {

620− \ return function(a) {\

718+ return function(a) {

621− \ return function(b) {\

719+ return function(b) {

622− \ return function(c) {\

720+ return function(c) {

623− \ return function(d) {\

721+ return function(d) {

624− \ return fn(a, b, c, d);\

722+ return fn(a, b, c, d);

625− \ };\

723+ };

626− \ };\

724+ };

627− \ };\

725+ };

628− \ };\

726+ };

727+ }

629− \}" :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e

728+ """ :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e

630

729

631 foreign import runFn5

730 foreign import runFn5

731+ """

632− "function runFn5(fn) {\

732+ function runFn5(fn) {

633− \ return function(a) {\

733+ return function(a) {

634− \ return function(b) {\

734+ return function(b) {

635− \ return function(c) {\

735+ return function(c) {

636− \ return function(d) {\

736+ return function(d) {

637− \ return function(e) {\

737+ return function(e) {

638− \ return fn(a, b, c, d, e);\

738+ return fn(a, b, c, d, e);

639− \ };\

739+ };

640− \ };\

740+ };

641− \ };\

741+ };

642− \ };\

742+ };

643− \ };\

743+ };

744+ }

644− \}" :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f

745+ """ :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f

645

746

646 foreign import runFn6

747 foreign import runFn6

748+ """

647− "function runFn6(fn) {\

749+ function runFn6(fn) {

648− \ return function(a) {\

750+ return function(a) {

649− \ return function(b) {\

751+ return function(b) {

650− \ return function(c) {\

752+ return function(c) {

651− \ return function(d) {\

753+ return function(d) {

652− \ return function(e) {\

754+ return function(e) {

653− \ return function(f) {\

755+ return function(f) {

654− \ return fn(a, b, c, d, e, f);\

756+ return fn(a, b, c, d, e, f);

655− \ };\

757+ };

656− \ };\

758+ };

657− \ };\

759+ };

658− \ };\

760+ };

659− \ };\

761+ };

660− \ };\

762+ };

763+ }

661− \}" :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g

764+ """ :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g

662

765

663 foreign import runFn7

766 foreign import runFn7

767+ """

664− "function runFn7(fn) {\

768+ function runFn7(fn) {

665− \ return function(a) {\

769+ return function(a) {

666− \ return function(b) {\

770+ return function(b) {

667− \ return function(c) {\

771+ return function(c) {

668− \ return function(d) {\

772+ return function(d) {

669− \ return function(e) {\

773+ return function(e) {

670− \ return function(f) {\

774+ return function(f) {

671− \ return function(g) {\

775+ return function(g) {

672− \ return fn(a, b, c, d, e, f, g);\

776+ return fn(a, b, c, d, e, f, g);

777+ };

778+ };

673− \ };\

779+ };

674− \ };\

780+ };

675− \ };\

781+ };

676− \ };\

782+ };

677− \ };\

783+ };

678− \ };\

784+ }

679− \ };\

680− \}" :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h

785+ """ :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h

681

786

682 foreign import runFn8

787 foreign import runFn8

788+ """

683− "function runFn8(fn) {\

789+ function runFn8(fn) {

684− \ return function(a) {\

790+ return function(a) {

685− \ return function(b) {\

791+ return function(b) {

686− \ return function(c) {\

792+ return function(c) {

687− \ return function(d) {\

793+ return function(d) {

688− \ return function(e) {\

794+ return function(e) {

689− \ return function(f) {\

795+ return function(f) {

690− \ return function(g) {\

796+ return function(g) {

691− \ return function(h) {\

797+ return function(h) {

692− \ return fn(a, b, c, d, e, f, g, h);\

798+ return fn(a, b, c, d, e, f, g, h);

799+ };

800+ };

693− \ };\

801+ };

694− \ };\

802+ };

695− \ };\

803+ };

696− \ };\

804+ };

697− \ };\

805+ };

698− \ };\

806+ };

699− \ };\

807+ }

700− \ };\

701− \}" :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i

808+ """ :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i

702

809

703 foreign import runFn9

810 foreign import runFn9

811+ """

704− "function runFn9(fn) {\

812+ function runFn9(fn) {

705− \ return function(a) {\

813+ return function(a) {

706− \ return function(b) {\

814+ return function(b) {

707− \ return function(c) {\

815+ return function(c) {

708− \ return function(d) {\

816+ return function(d) {

709− \ return function(e) {\

817+ return function(e) {

710− \ return function(f) {\

818+ return function(f) {

711− \ return function(g) {\

819+ return function(g) {

712− \ return function(h) {\

820+ return function(h) {

713− \ return function(i) {\

821+ return function(i) {

714− \ return fn(a, b, c, d, e, f, g, h, i);\

822+ return fn(a, b, c, d, e, f, g, h, i);

823+ };

824+ };

715− \ };\

825+ };

716− \ };\

826+ };

717− \ };\

827+ };

718− \ };\

828+ };

719− \ };\

829+ };

720− \ };\

830+ };

721− \ };\

831+ };

722− \ };\

832+ }

723− \ };\

724− \}" :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j

833+ """ :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j

725

834

726 foreign import runFn10

835 foreign import runFn10

836+ """

727− "function runFn10(fn) {\

837+ function runFn10(fn) {

728− \ return function(a) {\

838+ return function(a) {

729− \ return function(b) {\

839+ return function(b) {

730− \ return function(c) {\

840+ return function(c) {

731− \ return function(d) {\

841+ return function(d) {

732− \ return function(e) {\

842+ return function(e) {

733− \ return function(f) {\

843+ return function(f) {

734− \ return function(g) {\

844+ return function(g) {

735− \ return function(h) {\

845+ return function(h) {

736− \ return function(i) {\

846+ return function(i) {

737− \ return function(j) {\

847+ return function(j) {

738− \ return fn(a, b, c, d, e, f, g, h, i, j);\

848+ return fn(a, b, c, d, e, f, g, h, i, j);

849+ };

850+ };

739− \ };\

851+ };

740− \ };\

852+ };

741− \ };\

853+ };

742− \ };\

854+ };

743− \ };\

855+ };

744− \ };\

856+ };

745− \ };\

857+ };

746− \ };\

858+ };

747− \ };\

859+ }

748− \ };\

749− \}" :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k

860+ """ :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k

750−

751−module Data.Eq where

752−

753− newtype Ref a = Ref a

754−

755− liftRef :: forall a b. (a -> a -> b) -> Ref a -> Ref a -> b

756− liftRef f (Ref x) (Ref y) = f x y

757−

758− instance eqRef :: Eq (Ref a) where

759− (==) = liftRef refEq

760− (/=) = liftRef refIneq

761−

762− instance functorRef :: Functor Ref where

763− (<$>) f (Ref x) = Ref (f x)

764

861

765module Prelude.Unsafe where

862module Prelude.Unsafe where

766

863

767 foreign import unsafeIndex

864 foreign import unsafeIndex

865+ """

768− "function unsafeIndex(xs) {\

866+ function unsafeIndex(xs) {

769− \ return function(n) {\

867+ return function(n) {

770− \ return xs[n];\

868+ return xs[n];

771− \ };\

869+ };

870+ }

772− \}" :: forall a. [a] -> Number -> a

871+ """ :: forall a. [a] -> Number -> a

773

872

774module Control.Monad.Eff where

873module Control.Monad.Eff where

775

874

776 foreign import data Eff :: # ! -> * -> *

875 foreign import data Eff :: # ! -> * -> *

777

876

778− foreign import returnE "function returnE(a) {\

877+ foreign import returnE

878+ """

879+ function returnE(a) {

779− \ return function() {\

880+ return function() {

780− \ return a;\

881+ return a;

781− \ };\

882+ };

883+ }

782− \}" :: forall e a. a -> Eff e a

884+ """ :: forall e a. a -> Eff e a

783−

885+

784− foreign import bindE "function bindE(a) {\

886+ foreign import bindE

887+ """

888+ function bindE(a) {

785− \ return function(f) {\

889+ return function(f) {

786− \ return function() {\

890+ return function() {

787− \ return f(a())();\

891+ return f(a())();

788− \ };\

892+ };

789− \ };\

893+ };

894+ }

790− \}" :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b

895+ """ :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b

791

896

792 type Pure a = forall e. Eff e a

897 type Pure a = forall e. Eff e a

793

898

794− foreign import runPure "function runPure(f) {\

899+ foreign import runPure

900+ """

901+ function runPure(f) {

795− \ return f();\

902+ return f();

903+ }

796− \}" :: forall a. Pure a -> a

904+ """ :: forall a. Pure a -> a

797

905

798 instance functorEff :: Functor (Eff e) where

906 instance functorEff :: Functor (Eff e) where

799 (<$>) = liftA1

907 (<$>) = liftA1

809

917

810 instance monadEff :: Monad (Eff e)

918 instance monadEff :: Monad (Eff e)

811

919

812− foreign import untilE "function untilE(f) {\

920+ foreign import untilE

921+ """

922+ function untilE(f) {

813− \ return function() {\

923+ return function() {

814− \ while (!f());\

924+ while (!f());

815− \ return {};\

925+ return {};

816− \ };\

926+ };

927+ }

817− \}" :: forall e. Eff e Boolean -> Eff e Unit

928+ """ :: forall e. Eff e Boolean -> Eff e Unit

818−

929+

819− foreign import whileE "function whileE(f) {\

930+ foreign import whileE

931+ """

932+ function whileE(f) {

820− \ return function(a) {\

933+ return function(a) {

821− \ return function() {\

934+ return function() {

822− \ while (f()) {\

935+ while (f()) {

823− \ a();\

936+ a();

824− \ }\

937+ }

825− \ return {};\

938+ return {};

826− \ };\

939+ };

827− \ };\

940+ };

941+ }

828− \}" :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit

942+ """ :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit

829−

943+

830− foreign import forE "function forE(lo) {\

944+ foreign import forE

945+ """

946+ function forE(lo) {

831− \ return function(hi) {\

947+ return function(hi) {

832− \ return function(f) {\

948+ return function(f) {

833− \ return function() {\

949+ return function() {

834− \ for (var i = lo; i < hi; i++) {\

950+ for (var i = lo; i < hi; i++) {

835− \ f(i)();\

951+ f(i)();

836− \ }\

952+ }

837− \ };\

953+ };

838− \ };\

954+ };

839− \ };\

955+ };

956+ }

840− \}" :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit

957+ """ :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit

841−

958+

842−

959+

843− foreign import foreachE "function foreachE(as) {\

960+ foreign import foreachE

961+ """

962+ function foreachE(as) {

844− \ return function(f) {\

963+ return function(f) {

845− \ return function() {\

964+ return function() {

846− \ for (var i = 0; i < as.length; i++) {\

965+ for (var i = 0; i < as.length; i++) {

847− \ f(as[i])();\

966+ f(as[i])();

848− \ }\

967+ }

849− \ };\

968+ };

850− \ };\

969+ };

970+ }

851− \}" :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit

971+ """ :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit

852

972

853module Control.Monad.Eff.Unsafe where

973module Control.Monad.Eff.Unsafe where

854

974

855 import Control.Monad.Eff

975 import Control.Monad.Eff

856

976

857 foreign import unsafeInterleaveEff

977 foreign import unsafeInterleaveEff

978+ """

858− "function unsafeInterleaveEff(f) {\

979+ function unsafeInterleaveEff(f) {

859− \ return f;\

980+ return f;

981+ }

860− \}" :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a

982+ """ :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a

861

983

862module Debug.Trace where

984module Debug.Trace where

863

985

865

987

866 foreign import data Trace :: !

988 foreign import data Trace :: !

867

989

868− foreign import trace "function trace(s) {\

990+ foreign import trace

991+ """

992+ function trace(s) {

869− \ return function() {\

993+ return function() {

870− \ console.log(s);\

994+ console.log(s);

871− \ return {};\

995+ return {};

872− \ };\

996+ };

997+ }

873− \}" :: forall r. String -> Eff (trace :: Trace | r) Unit

998+ """ :: forall r. String -> Eff (trace :: Trace | r) Unit

874

999

875 print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit

1000 print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit

876 print o = trace (show o)

1001 print o = trace (show o)

883

1008

884 foreign import data STRef :: * -> * -> *

1009 foreign import data STRef :: * -> * -> *

885

1010

886− foreign import newSTRef "function newSTRef(val) {\

1011+ foreign import newSTRef

1012+ """

1013+ function newSTRef(val) {

887− \ return function() {\

1014+ return function() {

888− \ return { value: val };\

1015+ return { value: val };

889− \ };\

1016+ };

1017+ }

890− \}" :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)

1018+ """ :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)

891−

1019+

892− foreign import readSTRef "function readSTRef(ref) {\

1020+ foreign import readSTRef

1021+ """

1022+ function readSTRef(ref) {

893− \ return function() {\

1023+ return function() {

894− \ return ref.value;\

1024+ return ref.value;

895− \ };\

1025+ };

1026+ }

896− \}" :: forall a h r. STRef h a -> Eff (st :: ST h | r) a

1027+ """ :: forall a h r. STRef h a -> Eff (st :: ST h | r) a

897−

1028+

898− foreign import modifySTRef "function modifySTRef(ref) {\

1029+ foreign import modifySTRef

1030+ """

1031+ function modifySTRef(ref) {

899− \ return function(f) {\

1032+ return function(f) {

900− \ return function() {\

1033+ return function() {

901− \ return ref.value = f(ref.value);\

1034+ return ref.value = f(ref.value);

902− \ };\

1035+ };

903− \ };\

1036+ };

1037+ }

904− \}" :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a

1038+ """ :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a

905−

1039+

906− foreign import writeSTRef "function writeSTRef(ref) {\

1040+ foreign import writeSTRef

1041+ """

1042+ function writeSTRef(ref) {

907− \ return function(a) {\

1043+ return function(a) {

908− \ return function() {\

1044+ return function() {

909− \ return ref.value = a;\

1045+ return ref.value = a;

910− \ };\

1046+ };

911− \ };\

1047+ };

1048+ }

912− \}" :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a

1049+ """ :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a

913−

1050+

914− foreign import runST "function runST(f) {\

1051+ foreign import runST

1052+ """

1053+ function runST(f) {

915− \ return f;\

1054+ return f;

1055+ }

916− \}" :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a

1056+ """ :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a

917

1057

918 pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a

1058 pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a

919 pureST st = runPure (runST st)

1059 pureST st = runPure (runST st)