[2/?] Add ability to run code examples in the playground: Extend code samples to be runnable

[shaedrich]

See #340

As per https://github.com/ponylang/pony-tutorial/pull/542#issuecomment-2113695598

Stats

• runnable: 148
• not runnable: 157
• erroring: 6
• open questions: 3

Files

Getting Started

• [x] hello-world-main.pony → prints

  Hello, world!

  • [x] hello-world.md: --8<-- "hello-world-main.pony → runnable
  • [x] how-it-works.md: --8<-- "hello-world-main.pony → runnable
  • [x] how-it-works.md: --8<-- "hello-world-main.pony::1 → not runnable
  • [x] how-it-works.md: --8<-- "hello-world-main.pony:2:2 → not runnable
  • [x] how-it-works.md: --8<-- "hello-world-main.pony:3:3 → not runnable

Types

• [x] classes-swap-values-sugar.pony → prints

  a = 1, b = 2 a = 2, b = 1

  • [x] --8<-- "classes-swap-values-sugar.pony:6:6" → runnable
• [x] classes-swap-values.pony → prints

  a = 1, b = 2 a = 2, b = 1

  • [x] --8<-- "classes-swap-values.pony:6:8" → runnable
• [ ] classes-wombat-constructor-invocation.pony (see classes-wombat.pony)
• [x] classes-wombat-constructors.pony → prints

  Your default wombat's name is "Fantastibat" Your hungry wombat's name is "Nomsbat"

  • [x] --8<-- "classes-wombat.pony:8:18" → runnable
• [x] classes-wombat.pony → prints

  Fantastibat has a hunger level of 5 Nomsbat has a hunger level of 12

  • [x] --8<-- "classes-wombat.pony:1:19:9" → not runnable
  • [x] --8<-- "classes-wombat.pony:1:39:11" → not runnable
  • [x] --8<-- "classes-wombat-constructor-invocation.pony:3:4" → runnable
• [ ] classes-zero-argument-constructors-invocation.pony (see classes-zero-argument-constructors.pony)
• [x] classes-zero-argument-constructors.pony → no output (is that desireble?)
  • [x] --8<-- "classes-zero-argument-constructors.pony:9:16" → runnable
  • [x] --8<-- "classes-zero-argument-constructors-invocation.pony:5:17" → runnable
• [x] primitives-doors.pony → prints

  Is door open? false 2 + 3 = 5

  (Does it even make sense to have these two things together in one example?)
  • [x] --8<-- "primitives-doors.pony" → runnable
• [ ] actors-behaviors.pony (How to print anything useful?)
• [x] actors-sequential.pony → prints

  This is printed first This is printed last

• [x] traits-and-interfaces-marker-methods.pony
  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-marker-methods.pony:1:1" → not runnable
  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-marker-methods.pony" → not runnable
• [x] traits-and-interfaces-multiple-traits.pony → prints

  Their name is "Bob" and they are not bald

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-multiple-traits.pony:6:12" → runnable
• [x] traits-and-interfaces-nested-traits.pony → prints

  Their name is "Bob" and they are not bald

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-nested-traits.pony:6:12" → runnable
• [x] traits-and-interfaces-nominal-and-structural-subtyping.pony →

  Their name is "Bob" Their name is "Larry"

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-nominal-and-structural-subtyping.pony:8:14" → runnable
• [x] traits-and-interfaces-nominal-subtyping-in-pony.pony → prints

  Their name is "Larry"

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-nominal-subtyping-in-pony:6:7" → runnable
• [x] traits-and-interfaces-nominal-subtyping.pony → not runnable
• [x] traits-and-interfaces-open-world-enumerations.pony → not runnable
• [ ] traits-and-interfaces-open-world-interface.pony (see traits-and-interfaces-marker-methods.pony)
• [x] traits-and-interfaces-open-world-typing.pony → prints

  size: 2, space: 8 size: 2, space: 8 size: 3, space: 8 size: 3, space: 4

  • [x] traits-and-interfaces.md: --8<-- "raits-and-interfaces-open-world-typing.pony:6:9" → runnable
• [x] traits-and-interfaces-private-methods.pony → runnable, fails with

  interfaces can't have private methods, only traits can

• [x] traits-and-interfaces-structural-subtyping-in-pony.pony → not runnable
• [x] traits-and-interfaces-structural-subtyping.pony → prints

  1 cannot be divided by 0

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-structural-subtyping.pony"--8<-- https://raw.githubusercontent.com/ponylang/ponyc/main/packages/builtin/stringable.pony

traits-and-interfaces-structural-subtyping.pony:18:19 --8<-- → runnable

• [x] traits-and-interfaces-trait.pony → prints

  Their name is "Bob"

  • [x] traits-and-interfaces.md: --8<-- "traits-and-interfaces-trait.pony:20:36" → runnable
• [x] traits-and-interfaces-type-union.pony → not runnable
• [x] structs-constructors.pony → not runnable
• [ ] structs-fields.pony
• [x] type-aliases-complex-types-interface.pony → prints

  Bob, aged 42, feels "Great!"

  • [x] type-aliases.md: --8<-- "type-aliases-complex-types-interface.pony:6:15"` → runnable
• [x] type-aliases-complex-types-trait.pony
  • [x] type-aliases.md: --8<-- "type-aliases-complex-types-trait.pony:6:15"` → runnable
• [x] type-aliases-enumerations-apply.pony → prints

  red: #FF0000FF green: #FF00FF blue: #FFFF

  • [x] type-aliases.md: --8<-- "type-aliases-enumerations-iteration.pony:15:19" → runnable
  • [x] type-aliases.md: --8<-- "type-aliases-enumerations-iteration.pony"--8<--
type-aliases-enumerations-apply.pony:21:23
type-aliases-enumerations-apply.pony:11:13
--8<--
• [ ] type-aliases-enumerations-iteration.pony (see type-aliases-enumerations-apply.pony)
• [x] type-aliases-enumerations-namespace.pony → not runnable
• [x] type-aliases-enumerations.pony → not runnable
• [x] type-aliases-hash-set.pony → not runnable
• [x] type-aliases-map.pony → not runnable
• [x] type-aliases-set-is.pony → not runnable
• [x] type-expressions-combined.pony → not runnable
• [x] type-expressions-intersection.pony → not runnable
• [x] type-expressions-tuple-declaration.pony → not runnable
• [x] type-expressions-tuple-destructuring.pony → not runnable
• [x] type-expressions-tuple-direct-access.pony → not runnable
• [x] type-expressions-tuple-reassignment.pony → not runnable
• [x] type-expressions-type-alias.pony → not runnable
• [x] type-expressions-union.pony → not runnable

Expressions

• [x] literals-array-literals.pony → prints

  first, second, third one on a new line first second third one on a new line first, second, third one on a new line first, second, third one on a new line first second third one on a new line

  • [x] literals.md: --8<-- "literals-array-literals.pony:3:7"` → runnable
• [x] literals-as-expression.pony → not runnable
• [x] literals-character-literals.pony → prints

  "A" (char 65) = "A" (char 65) = " " (char 10)

  • [x] literals.md: --8<-- "literals-character-literals.pony:3:5"` → runnable
• [x] literals-floats.pony → not runnable
• [x] literals-multi-line-string-literals.pony → not runnable
• [x] literals-multibyte-character-literals.pony → not runnable
• [x] literals-number-types.pony → prints

  1024 = 1024 = 1024

  • [x] literals.md: --8<-- "literals-number-types.pony:3:5"` → runnable
• [x] literals-numeric-typing.pony → not runnable
• [x] literals-string-literals-encoding.pony → runnable
  • [x] literals.md: --8<-- "literals-string-literals-encoding.pony:3:3"`
  • [x] + literals-string-literals-encoding-latin-1.pony
• [x] literals-string-literals-instances.pony → prints

  Same pony

  • [x] literals.md: --8<-- literals-string-literals-instances.pony:3:6 literals-string-literals-instances.pony:10:10 --8<--
• [x] literals-string-literals.pony → runnable, prints

  🐎 pönÿ 🐎 0xF0 0x9F 0x90 0x8E

• [x] literals-triple-quoted-string-literals.pony → not runnable
• [x] literals-type-inference-coercion.pony → not runnable
• [x] literals-type-inference-reference-capabilities.pony → not runnable
• [x] literals-type-inference-union.pony → not runnable
• [x] variables-fields-constructor-assignment.pony → prints

  Fantastibat has a hunger level of 5

  • [x] variables.md: --8<-- "variables-fields-constructor-assignment.pony:6:12"` → runnable
• [x] variables-fields-definition-assignment.pony → prints

  Fantastibat has a hunger level of 0

  • [x] variables.md: --8<-- "variables-fields-definition-assignment.pony:6:8"` → runnable
• [ ] variables-fields-implicit-assignment.pony → ⚠️ fails with

  receiver type is not a subtype of target type

• [x] variables-fields-let-reassignment.pony → fails with

  can't assign to a let or embed definition more than once

  • [x] variables.md: --8<-- "variables-fields-let-reassignment.pony:5:17"` → runnable
• [x] variables-let-reassignment.pony → fails with

  can't declare a let local without assigning to it

  • [x] variables.md: --8<-- "variables-let-reassignment.pony:3:5"` → runnable
• [x] variables-local-variables.pony → not runnable
• [x] variables-scope.pony → fails with

  can't find declaration of 'x'

  • [x] variables.md: --8<-- "variables-scope.pony:6:11"` → runnable
• [x] variables-var-vs-let.pony → fails with

  can't reassign to a let local

  • [x] variables.md: --8<-- "variables-var-vs-let.pony:3:6"` → runnable
• [x] operators-add.pony → prints

  (4, 6)

  • [x] operators.md: --8<-- "operators-add.pony"--8<-- operators-add.pony:8:19 operators-add.pony:23:29 --8<-- → runnable
• [x] operators-infix-operator.pony → not runnable
• [x] operators-operator-aliasing.pony → not runnable
• [ ] operators-precedence-infix-and-unary-operators-with-parentheses.pony
• [ ] operators-precedence-infix-and-unary-operators-without-parentheses.pony
• [x] operators-precedence-single-operator.pony → not runnable
• [x] operators-precedence-unary-operator-with-parentheses.pony → fails with

  Operator precedence is not supported. Parentheses required.

  • [x] operators.md: --8<-- " operators-precedence-unary-operator-with-parentheses.pony:3:3"` → runnable
• [x] operators-precedence-with-parentheses.pony → not runnable
• [x] operators-precedence-without-parentheses.pony → fails with

  Operator precedence is not supported. Parentheses required.

  • [x] operators.md: --8<-- "operators-precedence-without-parentheses.pony:3:3"` → runnable
• [x] operators-unary-operators.pony → not runnable
• [ ] arithmetic-default-integer-arithmetic.pony → ⚠️ not runnable, fails with

  Operator precedence is not supported. Parentheses required.

• [x] arithmetic-explicit-numeric-conversion.pony → not runnable
• [x] arithmetic-partial-and-check-arithmetic.pony → prints

  overflow detected overflow detected

  • [x] arithmetic.md: --8<-- "arithmetic-partial-and-check-arithmetic.pony"--8<-- arithmetic-partial-and-check-arithmetic.pony:7:14 arithmetic-partial-and-check-arithmetic.pony:16:20 arithmetic-partial-and-check-arithmetic.pony:22:22 arithmetic-partial-and-check-arithmetic.pony:24:26 --8<-- → runnable
• [x] arithmetic-unsafe-conversion.pony → not runnable
• [x] control-structures-conditionals-expression-implicit-none.pony → prints

  None

  • [x] control-structures.md: --8<-- "control-structures-conditionals-expression-implicit-none.pony:4:7"` → runnable
• [x] control-structures-conditionals-expression-union-type.pony → prints

  false

  • [x] control-structures.md: --8<-- "control-structures-conditionals-expression-union-type.pony:4:9"` → runnable
• [x] control-structures-conditionals-expressions.pony → prints

  x = 101—that's lots

  • [x] control-structures.md: --8<-- "control-structures-conditionals-expressions.pony:5:5"` → runnable
• [x] control-structures-conditionals-if-else.pony → prints

  a is not bigger

  • [x] control-structures.md: --8<-- "control-structures-conditionals-if-else.pony:5:9"` → runnable
• [x] control-structures-conditionals-if-elseif-else.pony → prints

  a is bigger

  • [x] control-structures.md: --8<-- "control-structures-conditionals-if-elseif-else.pony:5:11"` → runnable
• [x] control-structures-conditionals-if.pony → prints

  a is bigger

  • [x] control-structures.md: --8<-- "control-structures-conditionals-if.pony:5:7"` → runnable
• [x] control-structures-conditionals-nested-if-else.pony → prints

  they are the same

  • [x] control-structures.md: --8<-- "control-structures-conditionals-nested-if-else.pony:5:13"` → runnable
• [x] control-structures-iterator-methods.pony → not runnable;
• [x] control-structures-loop-expression-else.pony → runnable, prints

  x is no names!

• [x] control-structures-loop-expression-none.pony → runnable, prints

  x is None

• [x] control-structures-loop-expression.pony → runnable, prints

  x is Sarah

• [x] control-structures-loops-for-while-comparison.pony → prints

  Bob Fred Sarah

  • [x] control-structures.md: --8<-- "control-structures-loops-for-while-comparison.pony:4:8"` → runnable
• [x] control-structures-loops-for.pony → prints

  Bob Fred Sarah

  • [x] control-structures.md: --8<-- "control-structures-loops-for.pony:3:5"` → runnable
• [x] control-structures-loops-repeat.pony → runnable,

  hello! hello! hello! hello! hello! hello! hello!

• [x] control-structures-loops-while-break-else.pony → prints

  name = Jack

  • [x] control-structures.md: --8<-- "control-structures-loops-while-break-else.pony:10:19"` → runnable
• [x] control-structures-loops-while.pony → prints

  1 2 3 4 5 6 7 8 9 10

  • [x] control-structures.md: --8<-- "control-structures-loops-while.pony:3:8"` → runnable
• [ ] match-expression.pony → ⚠️ not runnable, fails with

  Multiple possible types for literal

• [ ] match-capabilities-only.pony → no output (is that desireble?)
• [ ] match-capabilities.pony → no output (is that desireble?)
• [x] match-captures.pony → prints

  two other integer

  • [x] match.md: --8<-- "match-captures.pony:6:13"` → runnable
• [ ] match-custom-eq-operand.pony → no output (is that desireble?)
• [x] match-guards.pony → prints

  one other small integer two other big integer

  • [x] match.md: --8<-- "match-guards.pony:6:15"` → runnable
• [x] match-tuples-ignore-elements.pony → prints

  one other integer

  • [x] match.md: --8<-- "match-tuples-ignore-elements.pony:5:13"` → runnable
• [x] match-tuples.pony → prints

  one two

  • [x] match.md: --8<-- "match-tuples.pony:5:13"` → runnable
• [x] match-type-and-value.pony → prints

  two something else

  • [x] match.md: --8<-- "match-type-and-value.pony:6:14"` → runnable
• [ ] match-value-pattern-matching-vs-type-check.pony → no output (is that desireble?)
• [x] match-values.pony → prints

  two something else

  • [x] match.md: --8<-- "match-values.pony:6:14"` → runnable
• [x] as-operator-array-literal.pony → not runnable
• [x] as-operator-match-statement-comparison.pony → prints

  I'm a clean wombat! I feel squeaky clean!

  • [x] as.md: --8<-- "as-operator-match-statement-comparison.pony:11:23"` → runnable
• [x] as-operator-match-statement-without-try.pony → prints

  I'm a clean wombat! I feel squeaky clean!

  • [x] as.md: --8<-- "as-operator-match-statement-without-try.pony:11:19"` → runnable
• [x] as-operator-more-specific-interface-with-reference-capability.pony → prints

  I'm a clean wombat! I feel squeaky clean!

  • [x] as.md: --8<-- "as-operator-more-specific-interface-with-reference-capability.pony:11:18"` → runnable
• [x] as-operator-more-specific-interface.pony → runnable, prints

  I'm a clean wombat! I feel squeaky clean! I'm swimming like a fish!

• [ ] as-operator-more-specific-type.pony → ⚠️ error is silently discarded
• [x] as-operator-unrelated-type.pony → fails with

  Dog is alive but not well

  • [x] as.md: --8<-- "as-operator-unrelated-type.pony:1:10"` → runnable
• [x] methods-anonymous-methods.pony → runnable, prints

  1 3

• [ ] methods-chaining-return-value.pony → ⚠️ fails with "can't find definition of 'Option'"
• [x] methods-chaining.pony → not runnable
• [x] methods-constructors-calling-on-expression.pony → not runnable
• [x] methods-constructors-calling-reuse-variable-name.pony → not runnable
• [x] methods-constructors-calling.pony → not runnable
• [x] methods-constructors.pony → prints

  create: 0 from_int: 42

  • [x] methods.md: --8<-- "methods-constructors.pony:6:13"` → runnable
• [x] methods-default-arguments.pony → not runnable
• [x] methods-functions-calling-implicit-this.pony → not runnable
• [x] methods-functions-calling.pony → not runnable
• [x] methods-functions.pony → prints

  add: 3 nop: None

  • [x] methods.md: --8<-- "methods-functions.pony:6:11"` → runnable
• [x] methods-named-and-positional-arguments-combined.pony → not runnable
• [x] methods-named-arguments.pony → not runnable
• [x] errors-dispose-multiple.pony → not runnable
• [x] errors-dispose.pony → not runnable
• [x] errors-partial-functions.pony → prints

  factorial(5) results in 120

  , fails with

  factorial(-5) failed

  • [x] errors.md: --8<-- "errors-partial-functions.pony:16:22"` → runnable
• [x] errors-try-else.pony → fails with

  callB() resulted in an error

  • [x] errors.md: --8<-- "errors-try-else.pony:9:15"` → runnable
• [x] errors-try-then.pony → prints

  I don't know whether callB() was executed successfully ¯_ (ツ)_/¯ I get executed either way

  , fails with

  callB() resulted in an error

  • [x] errors.md: --8<-- "errors-try-then.pony:9:17"` → runnable
• [x] errors-try-without-else.pony → not runnable
• [x] errors-with-blocks.pony → not runnable
• [x] equality-equatable-default-implementation.pony → not runnable
• [x] equality-identity-equality.pony → not runnable
• [x] equality-primitives.pony → not runnable
• [x] equality-structural-equality.pony → runnable
• [x] sugar-apply-explicit.pony → not runnable
• [x] sugar-apply-implicit.pony → not runnable
• [x] sugar-apply-with-arguments-explicit.pony → not runnable
• [x] sugar-apply-with-arguments-implicit.pony → not runnable
• [ ] sugar-create-apply-combined-explicit.pony
• [ ] sugar-create-apply-combined-implicit.pony
• [x] sugar-create-explicit.pony → not runnable
• [x] sugar-create-implicit.pony → not runnable
• [x] sugar-create-with-arguments-explicit.pony → not runnable
• [x] sugar-create-with-arguments-implicit.pony → not runnable
• [x] sugar-update-additional-parameters.pony → prints

  foo = 5 foo1 = 23 foo2 = 0 foo3 = 379.5

  • [x] sugar.md: --8<-- "update-additional-parameters.pony:18:18"` → runnable
• [x] sugar-update-explicit.pony → prints

  foo = 10 foo = 370

  • [x] sugar.md: --8<-- "sugar-update-explicit.pony:18:18"` → runnable
• [x] sugar-update-implicit.pony → prints

  foo = 10 foo = 370

  • [x] sugar.md: --8<-- "sugar-update-implicit.pony:18:18"` → runnable
• [x] object-literals-actor-literal.pony → prints

  hi

  • [x] object-literals.md: --8<-- "object-literals-actor-literal.pony:4:6"` → runnable
• [x] object-literals-closing-over-values.pony
  • [x] object-literals.md: --8<-- "object-literals-fields-assignment.pony:1:8"` → runnable
• [x] object-literals-fields-assignment.pony → prints

  hello world: 14657180516326564906

  • [x] object-literals.md: --8<-- "object-literals-fields-assignment.pony:1:9"` → runnable
• [x] object-literals-lambda-as-explicit-object-literal.pony → prints

  lambda: hello world

  • [x] object-literals.md: --8<-- "object-literals-lambda-as-explicit-object-literal.pony:4:6"` → runnable
• [x] object-literals-lambda-capture-and-rename-values.pony → prints

  Hello World

  • [x] object-literals.md: --8<-- "object-literals-lambda-captur-eand-rename-values.pony:6:7"` → runnable
• [x] object-literals-lambda-capture-values.pony → prints

  Hello World

  • [x] object-literals.md: --8<-- "object-literals-lambda-capture-values.pony:5:10"` → runnable
• [x] object-literals-lambda-reference-capabilities-2.pony → runnable, prints

  hello world Count: 0

• [x] object-literals-lambda-reference-capabilities.pony → runnable, prints

  Result: 100

• [x] object-literals-lambda-with-reference-capability-as-explicit-object-literal.pony → prints

  lambda: hello world

  • [x] object-literals.md: --8<-- "object-literals-lambda-with-reference-capability-as-explicit-object-literal.pony:4:6"` → runnable
• [x] object-literals-lambda-with-reference-capability.pony → prints

  lambda: hello world

  • [x] object-literals.md: --8<-- "object-literals-lambda-as-with-reference-capability.pony:4:4"` → runnable
• [x] object-literals-lambda.pony → prints

  lambda: hello world

  • [x] object-literals.md: --8<-- "object-literals-lambda.pony:5:5"` → runnable
• [x] object-literals-object-literal-with-interface.pony → prints

  hi: 7970167862792651685

  • [x] object-literals.md: --8<-- "object-literals-object-literal-with-interface.pony:6:9"` → runnable
• [x] object-literals-object-literal.pony → prints

  hi

  • [x] object-literals.md: --8<-- "object-literals-object-literal.pony:4:6"` → runnable
• [x] object-literals-reference-capability.pony
  • [x] object-literals.md: --8<-- "object-literals-fields-assignment.pony:1:9"` → runnable
• [x] partial-application-callback-function-with-all-arguments-bound.pony → not runnable;
• [x] partial-application-callback-function-with-no-arguments-bound.pony → not runnable;
• [x] partial-application-callback-function-with-out-of-order-arguments.pony → not runnable;
• [x] partial-application-callback-function-with-some-arguments-bound.pony → not runnable;
• [x] partial-application-partially-applying-a-partial-application.pony → not runnable;

Reference capabilities

• [x] reference-capabilities-constructors-for-different-capabilities.pony → not runnable
• [x] reference-capabilities-default-vs-explicit.pony → not runnable
• [x] reference-capabilities-string-capabilities.pony → not runnable
• [x] reference-capabilities-string-default.pony → not runnable
• [x] reference-capability-specificy-a-capability-other-than-the-default.pony → not runnable
• [x] consume-and-destructive-read-consuming-a-variable-and-change-its-reference-capability.pony → not runnable
• [x] consume-and-destructive-read-consuming-a-variable.pony
  • [x] consume-and-destructive-read.md --8<-- "consume-and-destructive-read-consuming-a-variable.pony:15:26" → runnable, prints nothing
  • [x] consume-and-destructive-read.md --8<-- "consume-and-destructive-read-consuming-a-variable-failure.pony:5:7" → runnable, fails with

    can't use a consumed local or field in an expression

• [x] consume-and-destructive-read-moving-a-value.pony → not runnable
• [x] recovering-capabilities-format-int.pony → not runnable
• [x] recovering-capabilities-ref-to-iso.pony → not runnable
• [x] recovering-capabilities-string-append.pony → prints

  hi

  • [x] recovering-capabilities.md: --8<-- "recovering-capabilities-string-append.pony:3:4"
• [x] recovering-capabilities-with-explicit-reference-capability.pony → prints

  key: Lorem

  • [x] recovering-capabilities.md: --8<-- "recovering-capabilities-with-explicit-reference-capability.pony:5:5" → runnable
• [x] aliasing-alias-types.pony → not runnable
• [x] aliasing-ephemeral-types.pony → not runnable
• [x] aliasing-iso-to-tag.pony → prints nothing
  • [x] aliasing.md: --8<-- "aliasing-iso-to-tag.pony:5:6" → runnable
• [x] aliasing-multiple-references-to-an-iso-object.pony → fails with

  right side must be a subtype of left side

  • [x] aliasing.md: --8<-- "aliasing-multiple-references-to-an-iso-object.pony:5:6" → runnable
• [x] aliasing-trn-to-box.pony → prints nothing
  • [x] aliasing.md: --8<-- "aliasing-trn-to-box.pony:5:6" → runnable
• [x] arrow-types-box.pony → not runnable
• [x] arrow-types-this.pony → not runnable
• [x] arrow-types-type-parameter.pony → not runnable

Object capabilities

• [x] derived-authority-authority-hierarchies.pony → not runnable
• [x] derived-authority-delegating-and-restricting-authority.pony → prints

  connect_failed

  • [x] derived-authority.md: --8<-- "derived-authority-delegating-and-restricting-authority.pony" → runnable
  • [x] derived-authority.md: --8<-- "derived-authority-delegating-and-restricting-authority.pony:18:18" → not runnable
• [ ] derived-authority-restrict-then-delegate-your-authority.pony → fails with

  try expression never results in an error

  • [x] derived-authority.md: --8<-- "derived-authority-restrict-then-delegate-your-authority.pony:16:22"

Generics

• [x] generics-and-reference-capabilities-accept-any-reference-capability.pony → runnable, fails with

  right side must be a subtype of left side</blockquote

• [x] generics-and-reference-capabilities-capability-generic-class.pony → runnable, prints

  Hello World 42

• [x] generics-and-reference-capabilities-default-capability-and-constraint.pony → not runnable
• [x] generics-and-reference-capabilities-explicit-constraint-and-default-capability.pony → not runnable
• [ ] generics-and-reference-capabilities-foo-iso-consume-iso-constructor-parameter.pony → ⚠️ prints essentially nothing. Is that desired?
• [ ] generics-and-reference-capabilities-foo-iso-consume-iso-function-parameter.pony → :warning: Probably a ref missing, could then just be a snippet of generics-and-reference-capabilities-foo-iso
• [x] generics-and-reference-capabilities-foo-iso.pony → runnable, fails with

  right side must be a subtype of left side

• [ ] generics-and-reference-capabilities-foo-ref-and-this-ref.pony → ⚠️ prints essentially nothing. Is that desired?
• [x] generics-and-reference-capabilities-foo-ref.pony → runnable, fails with

  function body isn't the result type

• [x] generic-constraints-foo-any-read.pony → runnable, prints

  hello World

• [x] generics-foo-non-generic.pony → runnable, prints

  42 21

• [x] generics-foo-string.pony → prints

  Hello

  • [x] generics.md: --8<-- "generics-foo-string.pony:1:9" → runnable
• [x] generics-foo-with-any-val.pony → runnable, prints

  42 21 1.5 Hello

• [ ] generics-generic-class-initialization.pony (see generics-foo-with-any-val.pony)
• [x] generics-generic-methods.pony → runnable, prints

  10 Hello

• [ ] generics-type-parameter-defaults-definition.pony → ⚠️ fails with

  type argument is outside its constraint

  • [x] generics.md: --8<-- "generics-type-parameter-defaults<del>-definition</del>.pony:1:9"
  • [x] generics.md: --8<-- "generics-type-parameter-defaults<del>-initialization</del>.pony:13:15"
• [ ] generics-type-parameter-defaults-initialization.pony (see generics-type-parameter-defaults-definition.pony)

Packages

• [ ] use-statement-collections.pony → not runnable?
• [x] use-statement-scheme-indicators-optional-package-scheme-specifier.pony → not runnable
• [x] use-statement-scheme-indicators-required-package-scheme-specifier.pony → not runnable
• [x] use-statement-time-now.pony → not runnable
• [x] use-statement-time.pony → not runnable take from time.pony
• [x] use-statement-use-names-conflict.pony → not runnable
• [x] use-statement-use-names-resolution-alternative.pony → not runnable
• [x] use-statement-use-names-resolution.pony → not runnable

Testing

• [x] ponycheck-ponytest-for-all.pony → not runnable, ⚠️ fails with

  argument not assignable to parameter

• [ ] ponycheck-ponytest.pony (see ponycheck-usage.pony)
• [x] ponycheck-usage-quickcheck.pony → not runnable, ⚠️ fails with

  argument not assignable to parameter

• [x] ponycheck-usage.pony → prints

  1 test started, 0 complete: my_first_property started 1 test started, 1 complete: my_first_property complete ---- Passed: my_first_property ---- ---- 1 test ran. ---- Passed: 1

  • [x] ponycheck.md: --8<-- "ponycheck-usage.pony:2:12" → runnable
  • [x] ponycheck.md: --8<-- "ponycheck-ponytest.pony"--8<-- ponycheck-usage.pony:1:3 ponycheck-usage.pony:14:19 --8<-- → runnable
• [x] ponytest-aggregation.pony → not runnable
• [x] ponytest-example.pony → runnable, prints

  1 test started, 0 complete: addition started 2 tests started, 0 complete: subtraction started 2 tests started, 1 complete: addition complete 2 tests started, 2 complete: subtraction complete ---- Passed: addition ---- Passed: subtraction ---- ---- 2 tests ran. ---- Passed: 2

C-FFI

• [x] c-ffi-callbacks-bare-functions-pass-to-c-api.pony → not runnable
• [x] c-ffi-callbacks-bare-functions.pony → not runnable
• [x] c-ffi-callbacks-bare-lambda-callback.pony → not runnable
• [x] c-ffi-callbacks-bare-lambda-struct.pony → not runnable
• [x] c-ffi-callbacks-sqlite3-callback-2.pony → not runnable
• [x] c-ffi-callbacks-sqlite3-callback.pony → not runnable
• [x] c-abi-jump-consistent-hashing.pony → prints

  -2

  • [x] c-abi.md: --8<-- "ac-abi-jump-consistent-hashing.pony:5:18" → runnable
• [ ] c-abi-pony-use-native-jump-consistent-hashing-c-implementation.pony → not runnable, ⚠️ fails with

  undefined reference to 'jch_chash'

  Do we need the C script to make this one run? Can we do that?
• [ ] calling-c-access-list-entry-with-explicit-return-type.pony → not runnable, ⚠️ fails with

  undefined reference to 'list_create'

• [ ] calling-c-access-list-entry-without-return-type.pony → not runnable, ⚠️ fails with

  can't find declaration of 'point'

• [ ] calling-c-addressof.pony → not runnable, fails with

  unexpected token var after use command

• [x] calling-c-default-method-in-primitive.pony → runnable, prints

  Hello from trait Foo

• [x] calling-c-default-method-in-trait.pony → runnable, fails with

  Can't call an FFI function in a default method or behavior

• [ ] calling-c-different-types-of-lists.pony → not runnable, ⚠️ fails with

  undefined reference to 'list_create'

• [ ] calling-c-ffi-functions-raising-errors.pony → not runnable, ⚠️ compilation silently fails
• [ ] calling-c-file-path.pony → not runnable, 💡 use file_path.pony
• [x] calling-c-from-c-struct.pony → prints

  This rect is 2 cm x 3 cm

  • [x] calling-c.md: --8<-- "calling-c-from-c-struct.pony:1:5"
• [ ] calling-c-generic-list.pony → not runnable, ⚠️ fails with

  undefined reference to 'list_create'

• [x] calling-c-ioctl-struct.pony → prints

  0

  • [x] calling-c.md: --8<-- "calling-c-ioctl-struct.pony"--8<-- calling-c-ioctl-struct.pony:1:8 calling-c-ioctl-struct.pony:11:15 --8<-- → runnable
• [ ] calling-c-memcpy.pony → not runnable, ⚠️ fails with

  can't use an undefined variable in an expression

• [ ] calling-c-pointer-to-opaque-c-type.pony → not runnable, ⚠️ fails with

  expected mandatory type declaration on field after x_dpy

• [ ] calling-c-type-signature-compatibility.pony → not runnable, ⚠️ compilation silently fails
• [x] calling-c-variadic-c-functions.pony → prints

  Elapsed: 4,10500000000

  • [x] calling-c.md: --8<-- "calling-c-variadic-c-functions.pony"--8<-- calling-c-variadic-c-functions.pony:1:2 calling-c-variadic-c-functions.pony:10:12 --8<-- → runnable
• [x] calling-c-writev-struct.pony → prints

  Hello from Pony!

  • [x] calling-c.md: --8<-- "calling-c-writev-struct.pony"--8<-- calling-c-writev-struct.pony:1:12 calling-c-writev-struct.pony:15:19 --8<-- → runnable
• [x] calling-c-writev-tuple.pony → prints

  Hello from Pony!

  • [x] calling-c.md: --8<-- "calling-c-writev-tuple.pony"--8<-- calling-c-writev-tuple.pony:1:2 calling-c-writev-tuple.pony:5:7 --8<-- → runnable
• [x] linking-c-use-lib-foo.pony → not runnable
• [x] linking-c-use-with-condition.pony → not runnable, fails with

  undefined reference to 'SSL_load_error_strings'

Gotchas

• [x] divide-by-zero-floats.pony → prints

  1.5÷0.5 = 3

  • [x] divide-by-zero.md → --8<-- "divide-by-zero.pony:4:4"" → runnable
• [x] divide-by-zero-partial.pony → not runnable
• [x] divide-by-zero-unsafe.pony → ⚠️ silently fails
• [x] divide-by-zero.pony → prints

  1÷0 = 0

  • [x] divide-by-zero.md → --8<-- "divide-by-zero.pony:3:3"" → runnable
• [x] garbage-collection.pony → not runnable
• [x] scheduling.pony → not runnable
• [x] function-call-side-effects.pony → runnable, prints

  42

• [x] recursion.pony → prints

  0 0

  • [x] recursion.md → --8<-- "recursion.pony:7:19"" → runnable

Appendices

• [x] appendices-annotations-empty-with-nosupertype-annotation.pony → prints

  None

  • [x] annotations.md: --8<-- "appendices-annotations-empty-with-nosupertype-annotation.pony:1:7" → runnable
• [x] appendices-annotations-empty-without-nosupertype-annotation.pony → runnable, fails with

  this capture violates capabilities, because the match would need to differentiate by capability at runtime instead of matching on type alone

• [x] appendices-annotations-likely-and-unlikely-annotations.pony → prints

  res = foo

  • [x] --8<-- "appendices-annotations-likely-and-unlikely-annotations.pony"--8<-- appendices-annotations-likely-and-unlikely-annotations.pony:12:14 appendices-annotations-likely-and-unlikely-annotations.pony:17:19 appendices-annotations-likely-and-unlikely-annotations.pony:22:24 appendices-annotations-likely-and-unlikely-annotations.pony:27:30 --8<-- → runnable
• [x] appendices-annotations-nodoc-annotation.pony → not runnable
• [x] appendices-annotations-packed-annotation.pony → prints

  { "x": 0, "y": 1 }

  • [x] annotations.md: --8<-- "appendices-annotations-packed-annotation.pony:1:3" → runnable
• [x] appendices-annotations-syntax.pony → not runnable
• [x] appendices-examples-access-command-line-arguments.pony → runnable, prints

  1 ./main ./main

• [x] appendices-examples-create-arrays-with-values.pony → prints

  You rolled a six You rolled a three You rolled a four You rolled a five You rolled a two You rolled a one

  • [x] examples.md: --8<-- "appendices-examples-create-arrays-with-values.pony:5:9" → runnable
• [x] appendices-examples-empty-class-functions.pony → not runnable
• [x] appendices-examples-enumeration-with-values-with-namespace.pony → prints

  black: #FF000000 red: #FFFF0000

  • [x] examples.md: --8<-- "appendices-examples-enumeration-with-values-with-namespace.pony:4:6" → runnable
• [x] appendices-examples-enumeration-with-values.pony → prints

  black: #FF000000 red: #FFFF0000

  • [x] examples.md: --8<-- "appendices-examples-enumeration-with-values.pony:4:5" → runnable
• [x] appendices-examples-iterable-enumerations.pony → not runnable
• [x] appendices-examples-modify-a-lexically-captured-variable-in-a-closure.pony → runnable, prints

  15 35

• [x] appendices-examples-operator-overloading.pony → not runnable
• [ ] appendices-examples-pass-array-of-values-to-ffi.pony → ⚠️ fails with

  syntax error: expected mandatory type declaration on field after a

• [x] appendices-examples-test-helper.pony → not runnable
• [x] appendices-examples-use-cli-package-to-parse-command-line-arguments.pony → fails with

  Error: missing value for required option at: 'output'

  (desired?)
• [x] appendices-examples-write-tests.pony → runnable, prints

  1 test started, 0 complete: u32/add started 1 test started, 1 complete: u32/add complete ---- Passed: u32/add ---- ---- 1 test ran. ---- Passed: 1

• [x] appendices-platform-dependent-code.pony → not runnable
• [x] appendices-serialization-compare-original-object-with-deserialized-object.pony → runnable, prints

  serialised representation is 60 bytes long (foo1 == foo2) is true

• [ ] appendices-serialization-custom-serialization.pony → ⚠️ Do we need the C script to make this one run? Can we do that?
• [x] appendices-whitespace-comments.pony → not runnable
• [x] appendices-whitespace-do-a-then-do-a-unary-negation-of-b.pony → prints

  1

  • [x] whitespace.md: --8<-- "appendices-whitespace-do-a-then-do-a-unary-negation-of-b.pony:14:15" → runnable
• [x] appendices-whitespace-docstrings.pony → not runnable
• [x] appendices-whitespace-subtract-b-from-a.pony → prints

  -2

  • [x] whitespace.md: --8<-- "appendices-whitespace-subtract-b-from-a.pony:14:14" → runnable
• [x] error-messages-left-side-is-immutable.pony → runnable, fails with

  left side is immutable

• [x] error-messages-left-side-must-be-something-that-can-be-assigned-to.pony → runnable, fails with

  can't assign to a let or embed definition more than once

• [x] error-messages-receiver-type-is-not-a-subtype-of-target-type.pony → runnable, fails with

  receiver type is not a subtype of target type

[netlify[bot]]

✅ Deploy Preview for pony-tutorial ready!

Name	Link
🔨 Latest commit	f3c555243bcf24ea093142427588539226d95b47
🔍 Latest deploy log	https://app.netlify.com/sites/pony-tutorial/deploys/665f5b08f477050008365761
😎 Deploy Preview	https://deploy-preview-545--pony-tutorial.netlify.app
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.

---

To edit notification comments on pull requests, go to your Netlify site configuration.

[shaedrich]

fyi: There's currently an issue with auto dedention (https://github.com/facelessuser/pymdown-extensions/issues/1945) when using the block format and splitting a snippet into multiple pieces: https://github.com/facelessuser/pymdown-extensions/issues/2385

[shaedrich]

Main problems with files tagged "not runnable", that could potentially be runnable

• Function or if body is just a comment
  • This could be turned into env.out.print("the comment") in some cases, except
    • when it's not Main::create(), where we have direct access to env
    • the comment is just "..."
  • Function bodies can be made empty
• There's Foo with the methods and variables and Bar where Foo is called
  • Bar could be turned into Main, which would be beneficial, because
    • Main is needed anyway
    • In Main::create(), we have direct access to env
• The relevant methods have return type None
  • when we return the relevant values, we can print them in Main::create()
• Unexecutable parts (...)
  • Comment them out (// ...)

[shaedrich]

When examples are taken from stdlib, wouldn't it make sense to use URL snippets (or, assuming, all the sites are on the same server, maybe another path in mkdocs.yml markdown_extensions.pymdownx.snippets.base_path would suffice) from https://github.com/ponylang/ponyc (example)?

[shaedrich]

Guide on how to read the PR description and what we might want to do with it

• ⚠️ items are snippets that either need to be fixed or a working implementation needs to be discussed
• "not runnable" is assigned to the best of my knowledge, but your opinion on this might differ. If you don't mind the number of "not runnable" snippets, that's fine with me
• Some snippets are turned into multi-line snippets using the block format—while this is not inherently bad, some examples might be over-complicated
• "fails with" can be intended, excepted when it isn't
• strikethrough top-level items with a (see xyz.pony) comment are merged with other snippets, because both parts are needed to be runnable, and therefore should be fine

[shaedrich]

fyi: The deploy preview only fails due to flaky connectivity.

[SeanTAllen]

Error from the last build log:

12:41:17 PM: ERROR - Error reading page 'c-ffi/calling-c.md': Snippet at path 'https://raw.githubusercontent.com/ponylang/ponyc/main/packages/builtin/float.pony' could not be found

[SeanTAllen]

This is an impressive amount of work. Thank you @shaedrich.

[shaedrich]

This is an impressive amount of work. Thank you @shaedrich.

@SeanTAllen Thanks a lot 😊

Error from the last build log:

12:41:17 PM: ERROR - Error reading page 'c-ffi/calling-c.md': Snippet at path 'https://raw.githubusercontent.com/ponylang/ponyc/main/packages/builtin/float.pony' could not be found

@SeanTAllen This is fixed by the revert requested by @jemc

[jemc]

Is this PR meant to be in a ready for review/merge state?

I ask because it's not marked as a draft, but there are unchecked checkboxes in the PR description.

It isn't clear to me whether we should be giving this a final review yet.

[shaedrich]

@jemc Please read the PR description as well as my previous comments. If none of them require any action in your opinion, the PR is indeed ready to be merged. The unchecked checkboxes mean, these code snippets are not runnable and might not have been changed in this PR, but this doesn't necessarily need to be a problem.

[shaedrich]

Well, what use is it to have an example being run by the playground and it just doesn't fail? When I use the playground, I want it to output something. Otherwise the tutorial can simply talk about code and I have to accept that it does what the text says.

[jemc]

I think what you've done here does add value to the kind of user who wants to click through on these code samples and run them in the playground. I don't think that will be a high volume of users, but I agree your work here adds value for them (which is why I marked it as approved).

However, I don't want to create new requirements for tutorial content that raise the bar for what needs to be created there. That's why I want to ensure that the future mechanism which tests these samples can run at least some samples in a mode where we're only verifying that they compile (which should be part of the minimum bar for tutorial content contribution - that the code samples compile if expected to compile, or fail with specified errors if they are expected to fail to compile).

In short, we have to balance the needs of both the tutorial reader and the tutorial contributor. The more friction we add to the tutorial contribution process, the harder it becomes to get volunteers to do the work.

[shaedrich]

fail with specified errors

This one is a bit puzzling to me. So, in essence, you want failure to be more defined than success? That doesn't make sense to me. You don't want to test beyond compilation, okay, but why bother with error codes/messages? Why not just make a *.txt file with one exception per line that isn't tested and be done with it? Low maintenance, exactly what you want.

[jemc]

I'm trying to engage in a good faith exchange of opinions and arguments/reasoning here, but it becomes hard to justify continuing that engagement when comments like this appear to be strawmanning me with an apparent petulant tone.

Why not just make a *.txt file with one exception per line that isn't tested and be done with it? Low maintenance, exactly what you want.

We've talked at length in this PR and elsewhere about "what I want" and that isn't it.

So, no.

[shaedrich]

I'm trying to engage in a good faith exchange of opinions and arguments/reasoning here, but it becomes hard to justify continuing that engagement when comments like this appear to be strawmanning me with an apparent petulant tone.

It's right when they say, the internet doesn't do a good point of getting one's point across in terms of the message's notions. If you indeed read my message in good faith, there is nothing that would objectively hint at a petulant tone.

What I'm trying to do is merely to understand your position, which I'm struggling to do, as I tried to convey in my last message. If you're willing to make this clear, I'm interested in your explanation. If you don't want to and still take this personally, there's not much I can do.

In more than one comment, I explicitly stated that I hope, I'm not speaking out of line by just stating my different opinion on the matter at hand because I thought, this perspective would be beneficial for the project.

I just listened to your sync recording, and I think, I understand one of your concerns better, concerning using stderr to determine if the code snippet run failed accordingly. Yeah, error messages could change, so something else should be used. Meaning, the problem is not with wanting to determine the reason of the run failing but the way of achieving that. However, this is complicated in itself, but might become easier if ponylang/rfcs#76 got implemented.