7b56ca8 · wock · git.iko.soy

git.iko.soy/wock

commit7b56ca8acfefed4ce4f128ca0e7ce40137bbf0f0 authoriko <mail@iko.soy> dateWed 13 Nov 2024, 21:36 (2 years ago) parentd206d0f

3 files changed+167−7

compare with master

unifiedsplit

nock/src/interpreter.rs+1−1 nock/src/noun.rs+157 wock-web/src/lib.rs+9−6

nock/src/interpreter.rs+1−1

@@ -424,7 +424,7 @@ pub fn ram_ttank(ctx: &mut InterpreterContext, ttank: TTank) -> String {

424424 ram(ctx, tank).unwrap_or(String::new())

425425}

426426

427−fn crip(ctx: &mut InterpreterContext, tape: Rc<Noun>) -> Result<Rc<Noun>, TTanks> {

427+pub fn crip(ctx: &mut InterpreterContext, tape: Rc<Noun>) -> Result<Rc<Noun>, TTanks> {

428428 RAP(ctx, &cell(&Rc::new(Noun::from_u32(3)), &tape))

429429}

430430

nock/src/noun.rs+157

@@ -47,6 +47,10 @@ impl PartialEq for Noun {

4747impl<'a> Noun {

4848 pub const SIG: Noun = Noun::Atom(BigUint::ZERO);

4949

50+ pub fn rc(self: Self) -> Rc<Self> {

51+ Rc::new(self)

52+ }

53+

5054 pub fn from_u32(a: u32) -> Noun {

5155 Noun::Atom(Atom::new(vec![a]))

5256 }

@@ -100,6 +104,13 @@ impl<'a> Noun {

100104 }

101105 }

102106

107+ pub fn as_cell_cloned(self: &'a Self) -> Option<(Rc<Noun>, Rc<Noun>)> {

108+ match self {

109+ Noun::Cell { p, q, .. } => Option::Some((p.clone(), q.clone())),

110+ _ => Option::None,

111+ }

112+ }

113+

103114 pub fn is_sig(self: &Self) -> bool {

104115 match self {

105116 Noun::Atom(n) if *n == Atom::ZERO => true,

@@ -244,6 +255,152 @@ impl<'a> Noun {

244255 }

245256}

246257

258+impl From<(Rc<Noun>, Rc<Noun>)> for Noun {

259+ fn from(value: (Rc<Noun>, Rc<Noun>)) -> Self {

260+ naked_cell(&value.0, &value.1)

261+ }

262+}

263+

264+impl From<(Rc<Noun>, Rc<Noun>, Rc<Noun>)> for Noun {

265+ fn from(value: (Rc<Noun>, Rc<Noun>, Rc<Noun>)) -> Self {

266+ naked_cell(&value.0, &cell(&value.1, &value.2))

267+ }

268+}

269+

270+impl From<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> for Noun {

271+ fn from(value: (Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)) -> Self {

272+ naked_cell(&value.0, &cell(&value.1, &cell(&value.2, &value.3)))

273+ }

274+}

275+

276+impl From<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> for Noun {

277+ fn from(value: (Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)) -> Self {

278+ naked_cell(

279+ &value.0,

280+ &cell(&value.1, &cell(&value.2, &cell(&value.3, &value.4))),

281+ )

282+ }

283+}

284+

285+impl From<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> for Noun {

286+ fn from(value: (Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)) -> Self {

287+ naked_cell(

288+ &value.0,

289+ &cell(

290+ &value.1,

291+ &cell(&value.2, &cell(&value.3, &cell(&value.4, &value.5))),

292+ ),

293+ )

294+ }

295+}

296+

297+impl

298+ From<(

299+ Rc<Noun>,

300+ Rc<Noun>,

301+ Rc<Noun>,

302+ Rc<Noun>,

303+ Rc<Noun>,

304+ Rc<Noun>,

305+ Rc<Noun>,

306+ )> for Noun

307+{

308+ fn from(

309+ value: (

310+ Rc<Noun>,

311+ Rc<Noun>,

312+ Rc<Noun>,

313+ Rc<Noun>,

314+ Rc<Noun>,

315+ Rc<Noun>,

316+ Rc<Noun>,

317+ ),

318+ ) -> Self {

319+ naked_cell(

320+ &value.0,

321+ &cell(

322+ &value.1,

323+ &cell(

324+ &value.2,

325+ &cell(&value.3, &cell(&value.4, &cell(&value.5, &value.6))),

326+ ),

327+ ),

328+ )

329+ }

330+}

331+

332+impl From<Noun> for Option<(Rc<Noun>, Rc<Noun>)> {

333+ fn from(value: Noun) -> Self {

334+ value.as_cell_cloned()

335+ }

336+}

337+

338+impl From<Noun> for Option<(Rc<Noun>, Rc<Noun>, Rc<Noun>)> {

339+ fn from(value: Noun) -> Self {

340+ let (a, b) = value.as_cell_cloned()?;

341+ let (b, c) = b.as_cell_cloned()?;

342+ Some((a, b, c))

343+ }

344+}

345+

346+impl From<Noun> for Option<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> {

347+ fn from(value: Noun) -> Self {

348+ let (a, b) = value.as_cell_cloned()?;

349+ let (b, c) = b.as_cell_cloned()?;

350+ let (c, d) = c.as_cell_cloned()?;

351+ Some((a, b, c, d))

352+ }

353+}

354+

355+impl From<Noun> for Option<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> {

356+ fn from(value: Noun) -> Self {

357+ let (a, b) = value.as_cell_cloned()?;

358+ let (b, c) = b.as_cell_cloned()?;

359+ let (c, d) = c.as_cell_cloned()?;

360+ let (d, e) = d.as_cell_cloned()?;

361+ Some((a, b, c, d, e))

362+ }

363+}

364+

365+impl From<Noun> for Option<(Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>, Rc<Noun>)> {

366+ fn from(value: Noun) -> Self {

367+ let (a, b) = value.as_cell_cloned()?;

368+ let (b, c) = b.as_cell_cloned()?;

369+ let (c, d) = c.as_cell_cloned()?;

370+ let (d, e) = d.as_cell_cloned()?;

371+ let (e, f) = e.as_cell_cloned()?;

372+ Some((a, b, c, d, e, f))

373+ }

374+}

375+

376+impl From<Noun>

377+ for Option<(

378+ Rc<Noun>,

379+ Rc<Noun>,

380+ Rc<Noun>,

381+ Rc<Noun>,

382+ Rc<Noun>,

383+ Rc<Noun>,

384+ Rc<Noun>,

385+ )>

386+{

387+ fn from(value: Noun) -> Self {

388+ let (a, b) = value.as_cell_cloned()?;

389+ let (b, c) = b.as_cell_cloned()?;

390+ let (c, d) = c.as_cell_cloned()?;

391+ let (d, e) = d.as_cell_cloned()?;

392+ let (e, f) = e.as_cell_cloned()?;

393+ let (f, g) = f.as_cell_cloned()?;

394+ Some((a, b, c, d, e, f, g))

395+ }

396+}

397+

398+impl From<&[u8]> for Noun {

399+ fn from(value: &[u8]) -> Self {

400+ Noun::from_bytes(value)

401+ }

402+}

403+

247404#[derive(Clone)]

248405pub struct Edge<'a> {

249406 pub hair: Hair,

wock-web/src/lib.rs+9−6

@@ -92,17 +92,20 @@ fn render_sail<'a>(ctx: &mut RenderContext<'a>, manx: Rc<Noun>) -> Node<'a> {

9292

9393 let binding = app.ctx.clone();

9494 let mut ctx = binding.borrow_mut();

95−

9695 let sig = ctx.nouns.sig.clone();

9796

98− let event = cell(&value, &sig);

97+ let step: Rc<Noun> = Rc::new((value.clone(), sig).into());

9998

10099 match slam(

101100 &mut ctx,

102101 &app.nock,

103− &cell(

104− &Rc::new(Noun::from_bytes(b"move")),

105− &cell(&app.model, &event),

102+ &Rc::new(

103+ (

104+ Noun::from_bytes(b"move").rc(),

105+ app.model.clone(),

106+ step.clone(),

107+ )

108+ .into(),

106109 ),

107110 ) {

108111 Ok(new_model) => {

@@ -117,7 +120,7 @@ fn render_sail<'a>(ctx: &mut RenderContext<'a>, manx: Rc<Noun>) -> Node<'a> {

117120

118121 error(&*format!(

119122 "Application failed to process event: {}",

120− event

123+ step

121124 ))

122125 }

123126 };