reference/library/4b.md · urbit.org

git.iko.soy/urbit.org

on cfa2bed help sign in

urbit.org/reference/library/4b.md

993 lines 15 kB history raw

1+++

2title = "4b: Text Processing"

3weight = 29

4template = "doc.html"

5+++

6### `++at`

8```

9 ++ at

10 |_ a=@

11```

13XX document

17### `++r:at`

19```

20 ++ r

21 ?: ?& (gte (met 3 a) 2)

22 |-

23 ?: =(0 a)

24 &

25 =+ vis=(end 3 1 a)

26 ?& ?|(=('-' vis) ?&((gte vis 'a') (lte vis 'z')))

27 $(a (rsh 3 1 a))

28 ==

29 ==

30 rtam

31 ?: (lte (met 3 a) 2)

32 rud

33 rux

34```

37XX document

39### `++rf:at`

41```

42 ++ rf `tape`[?-(a $& '&', $| '|', * !!) ~]

43```

46XX document

48### `++rn:at`

50```

51 ++ rn `tape`[?>(=(0 a) '~') ~]

52```

54XX document

56### `++rt:at`

58```

59 ++ rt `tape`['\'' (weld (mesc (trip a)) `tape`['\'' ~])]

60```

62XX document

64### `++rta:at`

66```

67 ++ rta rt

68```

70XX document

72### `++rtam:at`

74```

75 ++ rtam `tape`['%' (trip a)]

76```

78XX document

80### `++rub:at`

82```

83 ++ rub `tape`['0' 'b' (rum 2 ~ |=(b/@ (add '0' b)))]

84```

86XX document

88### `++rud:at`

90```

91 ++ rud (rum 10 ~ |=(b/@ (add '0' b)))

92```

94XX document

96### `++rum:at`

98```

99 ++ rum

100 |= {b/@ c/tape d/$-(@ @)}

101 ^- tape

102 ?: =(0 a)

103 [(d 0) c]

104 =+ e=0

105 |- ^- tape

106 ?: =(0 a)

107 c

108 =+ f=&(!=(0 e) =(0 (mod e ?:(=(10 b) 3 4))))

109 %= $

110 a (div a b)

111 c [(d (mod a b)) ?:(f [?:(=(10 b) ',' '-') c] c)]

112 e +(e)

113 ==

114 ::

115```

116

117XX document

118

119### `++rup:at`

120

121```

122 ++ rup

123 =+ b=(met 3 a)

124 ^- tape

125 :- '-'

126 |- ^- tape

127 ?: (gth (met 5 a) 1)

128 %+ weld

129 $(a (rsh 5 1 a), b (sub b 4))

130 `tape`['-' '-' $(a (end 5 1 a), b 4)]

131 ?: =(0 b)

132 ['~' ~]

133 ?: (lte b 1)

134 (trip (tos:po a))

135 |- ^- tape

136 ?: =(2 b)

137 =+ c=(rsh 3 1 a)

138 =+ d=(end 3 1 a)

139 (weld (trip (tod:po c)) (trip (tos:po (mix c d))))

140 =+ c=(rsh 3 2 a)

141 =+ d=(end 3 2 a)

142 (weld ^$(a c, b (met 3 c)) `tape`['-' $(a (mix c d), b 2)])

143 ::

144```

145

146XX document

147

148### `++ruv:at`

149

150```

151 ++ ruv

152 ^- tape

153 :+ '0'

154 'v'

155 %^ rum

156 64

157 ~

158 |= b/@

159 ?: =(63 b)

160 '+'

161 ?: =(62 b)

162 '-'

163 ?:((lth b 26) (add 65 b) ?:((lth b 52) (add 71 b) (sub b 4)))

164 ::

165```

166

167XX document

168

169### `++rux:at`

170

171```

172 ++ rux `tape`['0' 'x' (rum 16 ~ |=(b/@ (add b ?:((lth b 10) 48 87))))]

173 --

174 :::::::::::::::::::::::::::::::::::::::::::::::::::::: ::

175```

177XX document

179---

182---

184### `++cass`

186To lowercase

188Turn all occurences of uppercase letters in any `++tape` into lowercase

189letters. Returns a `++tape`.

190

191#### Accepts

192

193`vib` is a `++tape`.

195#### Produces

197A `++tape`.

199#### Source

201```

202 ++ cass :: lowercase

203 |= vib/tape

204 ^- tape

205 (turn vib |=(a/@ ?.(&((gte a 'A') (lte a 'Z')) a (add 32 a))))

206```

207

208#### Examples

209

210```

211 > (cass "JOHN DOE")

212 "john doe"

213

214 > (cass "abc ABC 123 !@#")

215 "abc abc 123 !@#"

216

217 > (cass "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsQqRrVvWwXxYyZz")

218 "aabbccddeeffgghhiijjkkllmmnnooppqqrrssqqrrvvwwxxyyzz"

219```

220

221---

222### `++crip`

223

224Tape to cord

225

226Produce a `++cord` from a `++tape`.

227

228#### Accepts

229

230`a` is a `++tape`.

232#### Produces

234A `++cord`.

236#### Source

238```

239 ++ crip |=(a=tape `@t`(rap 3 a)) :: tape to cord

240```

241

242#### Examples

243

244```

245 > (crip "john doe")

246 'john doe'

247

248 > (crip "abc 123 !@#")

249 'abc 123 !@#'

250

251 > `@ud`(crip "abc")

252 6.513.249

253```

254

255---

256### `++cuss`

257

258To uppercase

259

260Turn all occurences of lowercase letters in any `++tape` into uppercase

261letters. Returns a `++tape`.

262

263#### Accepts

264

265`vib` is a `++tape`.

267#### Produces

269A `++tape`.

271#### Source

273```

274 ++ cuss :: uppercase

275 |= vib/tape

276 ^- tape

277 (turn vib |=(a/@ ?.(&((gte a 'a') (lte a 'z')) a (sub a 32))))

278```

279

280#### Examples

281

282```

283 > (cuss "john doe")

284 "JOHN DOE"

285

286 > (cuss "abc ABC 123 !@#")

287 "ABC ABC 123 !@#"

288

289 > (cuss "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsQqRrVvWwXxYyZz")

290 "AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSQQRRVVWWXXYYZZ"

291```

292

293---

294### `++mesc`

295

296Escape special chars

297

298Escape special characters, used in `++show`.

299

300#### Accepts

301

302`vib` is a `++tape`.

304#### Produces

306A `++tape`.

308#### Source

310```

311 ++ mesc :: ctrl code escape

312 |= vib/tape

313 ^- tape

314 ?~ vib

315 ~

316 ?: =('\\' i.vib)

317 ['\\' '\\' $(vib t.vib)]

318 ?: ?|((gth i.vib 126) (lth i.vib 32) =(`@`39 i.vib))

319 ['\\' (welp ~(rux at i.vib) '/' $(vib t.vib))]

320 [i.vib $(vib t.vib)]

321```

322

323#### Examples

324

325```

326 > (mesc "ham lus")

327 "ham lus"

328 > (mesc "bas\\hur")

329 "bas\\\\hur"

330 > (mesc "as'saß")

331 "as\0x27/sa\0xc3/\0x9f/"

332```

333

334

335---

336### `++runt`

337

338Prepend `n` times

339

340Add `a` repetitions of character `b` to the head of `++tape` `c`.

341

342#### Accepts

343

344`a` and `b` are atoms.

345

346`c` is a `++tape`.

348#### Produces

350A `++tape`.

352#### Source

354```

355 ++ runt :: prepend repeatedly

356 |= [[a/@ b/@] c/tape]

357 ^- tape

358 ?: =(0 a)

359 c

360 [b $(a (dec a))]

361 ::

362```

363

364#### Examples

365

366```

367 > (runt [2 '/'] "ham")

368 "//ham"

369 > (runt [10 'a'] "")

370 "aaaaaaaaaa"

371```

372

373

374---

375### `++sand`

376

377Soft-cast by odor

378

379Soft-cast validity by odor.

380

381#### Accepts

382

383`a` is a `++span` (`@ta`).

385`b` is an atom.

387#### Produces

389A `(unit @)`.

391#### Source

393```

394 ++ sand :: atom sanity

395 |= a/@ta

396 |= b/@ ^- (unit @)

397 ?.(((sane a) b) ~ [~ b])

398 ::

399```

400

401#### Examples

402

403```

404 > `(unit @ta)`((sand %ta) 'sym-som')

405 [~ ~.sym-som]

406 > `(unit @ta)`((sand %ta) 'err!')

407 ~

408```

409

410

411---

412### `++sane`

413

414Check odor validity

415

416Check validity by odor. Produces a gate.

417

418#### Accepts

419

420`a` is a `++span` (`@ta`).

422`b` is an atom.

424#### Produces

426A boolean.

428#### Source

430```

431 ++ sane :: atom sanity

432 |= a/@ta

433 |= b/@ ^- ?

434 ?. =(%t (end 3 1 a))

435 ~|(%sane-stub !!)

436 =+ [inx=0 len=(met 3 b)]

437 ?: =(%tas a)

438 |- ^- ?

439 ?: =(inx len) &

440 =+ cur=(cut 3 [inx 1] b)

441 ?& ?| &((gte cur 'a') (lte cur 'z'))

442 &(=('-' cur) !=(0 inx) !=(len inx))

443 &(&((gte cur '0') (lte cur '9')) !=(0 inx))

444 ==

445 $(inx +(inx))

446 ==

447 ?: =(%ta a)

448 |- ^- ?

449 ?: =(inx len) &

450 =+ cur=(cut 3 [inx 1] b)

451 ?& ?| &((gte cur 'a') (lte cur 'z'))

452 &((gte cur '0') (lte cur '9'))

453 |(=('-' cur) =('~' cur) =('_' cur) =('.' cur))

454 ==

455 $(inx +(inx))

456 ==

457 |- ^- ?

458 ?: =(0 b) &

459 =+ cur=(end 3 1 b)

460 ?: &((lth cur 32) !=(10 cur)) |

461 =+ len=(teff cur)

462 ?& |(=(1 len) =+(i=1 |-(|(=(i len) &((gte (cut 3 [i 1] b) 128) $(i +(i)))))))

463 $(b (rsh 3 len b))

464 ==

465 ::

466```

467

468#### Examples

469

470```

471 > ((sane %tas) %mol)

472 %.y

473 > ((sane %tas) 'lam')

474 %.y

475 > ((sane %tas) 'more ace')

476 %.n

477```

478

479

480---

481### `++teff`

482

483UTF8 Length

484

485Produces the number of utf8 bytes.

487#### Accepts

489`a` is a `@t`.

491#### Produces

493An atom.

495#### Source

497```

498 |= a/@t ^- @

499 =+ b=(end 3 1 a)

500 ~| %bad-utf8

501 ?: =(0 b)

502 ?>(=(`@`0 a) 0)

503 ?> |((gte b 32) =(10 b))

504 ?:((lte b 127) 1 ?:((lte b 223) 2 ?:((lte b 239) 3 4)))

505```

506

507#### Examples

508

509```

510 > (teff 'a')

511 1

512 > (teff 'ß')

513 2

514```

515

516

517---

518### `++trim`

519

520Tape split

521

522Split first `a` characters off `++tape` `b`.

523

524#### Accepts

525

526`a` is an atom.

527

528`b` is a `++tape`.

529

530#### Produces

531

532A cell of `++tape`s, `p` and `q`.

533

534#### Source

535

536```

537 ++ trim :: 31-bit nonzero

538 |= key/@

539 =+ syd=0xcafe.babe

540 |- ^- @

541 =+ haz=(spec syd key)

542 =+ ham=(mix (rsh 0 31 haz) (end 0 31 haz))

543 ?.(=(0 ham) ham $(syd +(syd)))

544 --

545 ::

546```

547

548#### Examples

549

550```

551 > (trim 5 "lasok termun")

552 [p="lasok" q=" termun"]

553 > (trim 5 "zam")

554 [p="zam" q=""]

555```

556

557

558---

559### `++trip`

560

561Cord to tape

562

563Produce a `++tape` from `++cord`.

565#### Accepts

567`a` is an atom.

569#### Produces

571A `++tape`.

573#### Source

575```

576 ++ trip :: cord to tape

577 ~/ %trip

578 |= a/@ ^- tape

579 ?: =(0 (met 3 a))

580 ~

581 [^-(@ta (end 3 1 a)) $(a (rsh 3 1 a))]

582 ::

583```

584

585#### Examples

586

587```

588 > (trip 'john doe')

589 "john doe"

590 > (trip 'abc 123 !@#')

591 "abc 123 !@#"

592 > (trip 'abc')

593 "abc"

594```

595

596

597---

598### `++tuba`

599

600UTF8 to UTF32 tape

601

602Convert `++tape` to a `++list` of codepoints (`@c`).

603

604#### Accepts

605

606`a` is a `++tape`.

607

608#### Produces

609

610A `++list` of codepoints `@c`.

611

612#### Source

613

614```

615 ++ tuba :: utf8 to utf32 tape

616 |= a/tape

617 ^- (list @c)

618 (rip 5 (turf (rap 3 a))) :: XX horrible

619 ::

620```

621

622#### Examples

623

624```

625 > (tuba "я тут")

626 ~[~-~44f. ~-. ~-~442. ~-~443. ~-~442.]

627 > (tuba "chars")

628 ~[~-c ~-h ~-a ~-r ~-s]

629```

630

631

632---

633### `++tufa`

634

635UTF32 to UTF8 tape

636

637Wrap a `++list` of utf32 codepoints into a utf8 `++tape`.

638

639#### Accepts

640

641`a` is a `++list` of `@c`.

643#### Produces

645A `++tape`.

647#### Source

649```

650 ++ tufa :: utf32 to utf8 tape

651 |= a=(list @c)

652 ^- tape

653 ?~ a ""

654 (weld (rip 3 (tuft i.a)) $(a t.a))

655 ::

656```

657

658#### Examples

659

660```

661 > (tufa ~[~-~44f. ~-. ~-~442. ~-~443. ~-~442.])

662 "я тут"

663 > (tufa ((list @c) ~[%a %b 0xb1 %c]))

664 "ab±c"

665```

666

667

668---

669### `++tuft`

670

671UTF32 to UTF8 text

672

673Convert utf32 glyph to

674LSB utf8 `++cord`.

675

676#### Accepts

677

678`a` is a codepoint (`@c`).

680#### Produces

682A `++cord`.

684#### Source

686```

687 ++ tuft :: utf32 to utf8 text

688 |= a/@c

689 ^- @t

690 %+ rap 3

691 |- ^- (list @)

692 ?: =(`@`0 a)

693 ~

694 =+ b=(end 5 1 a)

695 =+ c=$(a (rsh 5 1 a))

696 ?: (lte b 0x7f)

697 [b c]

698 ?: (lte b 0x7ff)

699 :* (mix 0b1100.0000 (cut 0 [6 5] b))

700 (mix 0b1000.0000 (end 0 6 b))

701 c

702 ==

703 ?: (lte b 0xffff)

704 :* (mix 0b1110.0000 (cut 0 [12 4] b))

705 (mix 0b1000.0000 (cut 0 [6 6] b))

706 (mix 0b1000.0000 (end 0 6 b))

707 c

708 ==

709 :* (mix 0b1111.0000 (cut 0 [18 3] b))

710 (mix 0b1000.0000 (cut 0 [12 6] b))

711 (mix 0b1000.0000 (cut 0 [6 6] b))

712 (mix 0b1000.0000 (end 0 6 b))

713 c

714 ==

715```

716

717#### Examples

718

719```

720 > (tuft `@c`%a)

721 'a'

722 > (tuft `@c`0xb6)

723 '¶'

724```

725

726

727---

728### `++turf`

729

730UTF8 to UTF32 cord

731

732Convert utf8 (`++cord`) to utf32 codepoints.

734#### Accepts

736`a` is a `@t`.

738#### Produces

740A `@c`, UTF-32 codepoint.

741

742#### Source

743

744```

745 ++ turf :: utf8 to utf32

746 |= a/@t

747 ^- @c

748 %+ rap 5

749 |- ^- (list @c)

750 =+ b=(teff a)

751 ?: =(0 b) ~

752 =+ ^= c

753 %+ can 0

754 %+ turn

755 ^- (list {p/@ q/@})

756 ?+ b !!

757 $1 [[0 7] ~]

758 $2 [[8 6] [0 5] ~]

759 $3 [[16 6] [8 6] [0 4] ~]

760 $4 [[24 6] [16 6] [8 6] [0 3] ~]

761 ==

762 |=({p/@ q/@} [q (cut 0 [p q] a)])

763 ?. =((tuft c) (end 3 b a)) ~|(%bad-utf8 !!)

764 [c $(a (rsh 3 b a))]

765 ::

766```

767

768#### Examples

769

770```

771 > (turf 'my ßam')

772 ~-my.~df.am

773 > 'я тут'

774 'я тут'

775 > (turf 'я тут')

776 ~-~44f..~442.~443.~442.

777 > `@ux`'я тут'

778 0x82.d183.d182.d120.8fd1

779 > `@ux`(turf 'я тут')

780 0x442.0000.0443.0000.0442.0000.0020.0000.044f

781```

782

783

784---

785### `++wack`

786

787Coin format encode

788

789Escape `++span` `~` as `~~` and `_` as `~-`. Used for printing.

790

791#### Accepts

792

793`a` is a `++span` (`@ta`).

794

795#### Produces

796

797A `++span` (`@ta`).

798

799#### Source

800

801```

802 ++ wack :: coin format

803 |= a/@ta

804 ^- @ta

805 =+ b=(rip 3 a)

806 %+ rap 3

807 |- ^- tape

808 ?~ b

809 ~

810 ?: =('~' i.b) ['~' '~' $(b t.b)]

811 ?: =('_' i.b) ['~' '-' $(b t.b)]

812 [i.b $(b t.b)]

813 ::

814```

815

816#### Examples

817

818```

819 > (wack '~20_sam~')

820 ~.~~20~-sam~~

821

822 > `@t`(wack '~20_sam~')

823 '~~20~-sam~~'

824

825 > ~(rend co %many ~[`ud/5 `ta/'~20_sam'])

826 "._5_~~.~~20~-sam__"

827

828 > ._5_~~.~~20~-sam__

829 [5 ~.~20_sam]

830```

831

832---

833### `++wick`

834

835Coin format decode

836

837Unescape `++span` `~~` as `~` and `~-` as `_`.

839#### Accepts

841`a` is a an atom.

843#### Produces

845A `++span` `@ta`.

847#### Source

849```

850 ++ wick :: knot format

851 |= a/@

852 ^- (unit @ta)

853 =+ b=(rip 3 a)

854 =- ?^(b ~ (some (rap 3 (flop c))))

855 =| c/tape

856 |- ^- {b/tape c/tape}

857 ?~ b [~ c]

858 ?. =('~' i.b)

859 $(b t.b, c [i.b c])

860 ?~ t.b [b ~]

861 ?- i.t.b

862 $'~' $(b t.t.b, c ['~' c])

863 $'-' $(b t.t.b, c ['_' c])

864 @ [b ~]

865 ==

866 ::

867```

868

869#### Examples

870

871```

872 > `@t`(wick '~-ams~~lop')

873 '_ams~lop'

874

875 > `@t`(wick (wack '~20_sam~'))

876 '~20_sam~'

877```

878

879

880---

881### `++woad`

882

883Unescape cord

884

885Unescape `++cord` codepoints.

887#### Accepts

889`a` is a `@ta`.

891#### Produces

893A `++cord`.

895#### Source

897```

898 ++ woad :: cord format

899 |= a/@ta

900 ^- @t

901 %+ rap 3

902 |- ^- (list @)

903 ?: =(`@`0 a)

904 ~

905 =+ b=(end 3 1 a)

906 =+ c=(rsh 3 1 a)

907 ?: =('.' b)

908 [' ' $(a c)]

909 ?. =('~' b)

910 [b $(a c)]

911 => .(b (end 3 1 c), c (rsh 3 1 c))

912 ?+ b =- (weld (rip 3 (tuft p.d)) $(a q.d))

913 ^= d

914 =+ d=0

915 |- ^- {p/@ q/@}

916 ?: =('.' b)

917 [d c]

918 ?< =(0 c)

919 %= $

920 b (end 3 1 c)

921 c (rsh 3 1 c)

922 d %+ add (mul 16 d)

923 %+ sub b

924 ?: &((gte b '0') (lte b '9')) 48

925 ?>(&((gte b 'a') (lte b 'z')) 87)

926 ==

927 $'.' ['.' $(a c)]

928 $'~' ['~' $(a c)]

929 ==

930 ::

931```

932

933#### Examples

934

935```

936 > (woad ~.~b6.20.as)

937 '¶20 as'

938```

939

940

941---

942### `++wood`

943

944Escape cord

945

946Escape `++cord` codepoints.

947

948#### Accepts

949

950`a` is a `++span` (`@ta`).

951

952#### Produces

953

954A `++span` (`@ta`).

955

956#### Source

957

958```

959 ++ wood :: cord format

960 |= a/@t

961 ^- @ta

962 %+ rap 3

963 |- ^- (list @)

964 ?: =(`@`0 a)

965 ~

966 =+ b=(teff a)

967 =+ c=(turf (end 3 b a))

968 =+ d=$(a (rsh 3 b a))

969 ?: ?| &((gte c 'a') (lte c 'z'))

970 &((gte c '0') (lte c '9'))

971 =(`@`'-' c)

972 ==

973 [c d]

974 ?+ c

975 :- '~'

976 =+ e=(met 2 c)

977 |- ^- tape

978 ?: =(0 e)

979 ['.' d]

980 =. e (dec e)

981 =+ f=(rsh 2 e c)

982 [(add ?:((lte f 9) 48 87) f) $(c (end 2 e c))]

983 ::

984```

985

986#### Examples

987

988```

989 > (wood 'my ßam')

990 ~.my.~df.am

991```

992

993---